{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-1. Import TensorFlow and numpy Library and check if EagerExecution is True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python version: 3.9.5\n",
      "Tensorflow version: 2.9.1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from platform import python_version\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import os\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "print(f\"Python version: {python_version()}\")\n",
    "print(f\"Tensorflow version: {tf.__version__}\")\n",
    "os.environ['TF_CPP_MIN_LOG_LEVE L'] = '3'\n",
    "tf.executing_eagerly()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# Listing 2-2. Defining Zeros and Ones Tensors "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a tf.Tensor(\n",
      "[[0. 0.]\n",
      " [0. 0.]], shape=(2, 2), dtype=float32)\n",
      "b tf.Tensor(\n",
      "[[1. 1.]\n",
      " [1. 1.]], shape=(2, 2), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "# With eager execution we will be able to see the values of the tensor\n",
    "a = tf.zeros((2,2))\n",
    "print('a',a)\n",
    "b = tf.ones((2,2))\n",
    "print('b',b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-3. Sum the elements of the matrix (2D Tensor) across the horizontal axis "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([2. 2.], shape=(2,), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "out = tf.math.reduce_sum(b,axis=1)\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-4. Check the shape of the Tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([2, 2])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.get_shape()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-5. Reshaping a Tensor  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([[0. 0. 0. 0.]], shape=(1, 4), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "a_ = tf.reshape(a,(1,4))\n",
    "print(a_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-6. Converting a Tensor to Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "ta = a.numpy()\n",
    "print(ta) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-7.Defining TensorFlow Constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(10, shape=(), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "# Tensorflow constants are immutable \n",
    "a = tf.constant(2)\n",
    "b = tf.constant(5)\n",
    "c= a*b \n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-8 Illustration of difference between Eager Execution and Graph based execution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eager execution: tf.Tensor([10], shape=(1,), dtype=int32)\n",
      "Graph execution: tf.Tensor([10], shape=(1,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "import timeit\n",
    "# Eager function\n",
    "def func_eager(a,b):\n",
    "    return a*b\n",
    "# Graph function using tf.function on eager func\n",
    "@tf.function\n",
    "def graph_func(a,b):\n",
    "    return a*b\n",
    "\n",
    "a = tf.constant([2])\n",
    "b = tf.constant([5])\n",
    "\n",
    "# Eager execution\n",
    "print(\"Eager execution:\",func_eager(a,b))\n",
    "# Function with graph execution  \n",
    "print(\"Graph execution:\",graph_func(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-9 Execution time comparison of Eager Execution vs Graph Execution in Simple Operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eager execution: 0.0026365599915152416\n",
      "Graph execution: 0.0544749020045856\n",
      "For simple operations Graph execution takes more time..\n"
     ]
    }
   ],
   "source": [
    "import timeit\n",
    "# Eager function\n",
    "def func_eager(a,b):\n",
    "    return a*b\n",
    "# Graph function using tf.function on eager func\n",
    "@tf.function\n",
    "def graph_func(a,b):\n",
    "    return a*b\n",
    "\n",
    "a = tf.constant([2])\n",
    "b = tf.constant([5])\n",
    "\n",
    "# Eager execution\n",
    "print(\"Eager execution:\",timeit.timeit(lambda:func_eager(a,b),number=100))\n",
    "# Function with graph execution  \n",
    "print(\"Graph execution:\",timeit.timeit(lambda: graph_func(a,b),number=100))\n",
    "print(\"For simple operations Graph execution takes more time..\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-10 Execution time comparison of Eager Execution vs Graph Execution in a model inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eager time: 46.46772461201181\n",
      "Graph time: 23.970114473006106\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras import Input, Model\n",
    "from tensorflow.keras.layers import Flatten, Dense\n",
    "\n",
    "# Define the model (Inspired by mnist inputs)\n",
    "model = tf.keras.Sequential()\n",
    "model.add(tf.keras.Input(shape=(28,28,)))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(256,\"relu\"))\n",
    "model.add(Dense(128,\"relu\"))\n",
    "model.add(Dense(256,\"relu\"))\n",
    "model.add(Dense(10,\"softmax\"))\n",
    "# Dummy data with MNIST image sizes \n",
    "X = tf.random.uniform([1000, 28, 28])\n",
    "\n",
    "\n",
    "# Eager Execution to do inference (Model untrained as we are evauating speed of inference)\n",
    "eager_model = model\n",
    "print(\"Eager time:\", timeit.timeit(lambda: eager_model(X,training=False), number=10000))\n",
    "\n",
    "#Graph Execution to do inference (Model untrained as we are evauating speed of inference)\n",
    "graph_model = tf.function(eager_model) # Wrap the model with tf.function \n",
    "print(\"Graph time:\", timeit.timeit(lambda: graph_model(X,training=False), number=10000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-11. Defining TensorFlow variables \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intial value of Variable w = [ 5. 10.]\n",
      "New assigned value of Variable w = [2. 2.]\n"
     ]
    }
   ],
   "source": [
    "w = tf.Variable([5.,10])\n",
    "\n",
    "print('Intial value of Variable w =', w.numpy())\n",
    "w.assign([2.,2.])\n",
    "print('New assigned value of Variable w =', w.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-12.Converting a Numpy array to Tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[-0.78527151 -0.24655196 -1.46398214]\n",
      " [ 0.52133169  1.32163985  0.14126499]\n",
      " [ 0.67573942  0.37336583  0.73968285]\n",
      " [ 0.5907797   0.03879883 -0.28792242]\n",
      " [-3.00804685  0.69147973  1.11958851]], shape=(5, 3), dtype=float64)\n"
     ]
    }
   ],
   "source": [
    "nt = np.random.randn(5,3)\n",
    "nt_tensor = tf.convert_to_tensor(nt)\n",
    "print(nt_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-13. Computing Gradient "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.0\n"
     ]
    }
   ],
   "source": [
    "#Tensorflow needs to remember the order of operation in forward pass so that during the backward pass \n",
    "#(backpropagation) TensorFlow can traverse the list of operations in reverse order to compute gradients\n",
    "#tf.GradientTape is precisely the method that provides a way of recording relevant operations executed within its scope so that the information \n",
    "#can be used to compute the gradient  \n",
    "x = tf.Variable(2.0)\n",
    "\n",
    "with tf.GradientTape() as tape:\n",
    "    y = x**3\n",
    "\n",
    "dy_dx = tape.gradient(y,x) # Compute gradient of y wrt to x at x =2. \n",
    "\n",
    "print(dy_dx.numpy()) # dy/dx = ( 3(x^2) at x = 2 ) == 3*(2^2) = 12.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-14 Gradient with respect to Model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense_4 (Dense)             (None, 5)                 15        \n",
      "                                                                 \n",
      " dense_5 (Dense)             (None, 1)                 6         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 21\n",
      "Trainable params: 21\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n",
      "dense_4/kernel:0, shape: (2, 5)\n",
      "dense_4/bias:0, shape: (5,)\n",
      "dense_5/kernel:0, shape: (5, 1)\n",
      "dense_5/bias:0, shape: (1,)\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras import Input, Model\n",
    "from tensorflow.keras.layers import Flatten, Dense\n",
    "\n",
    "# Define the model \n",
    "model = tf.keras.Sequential()\n",
    "model.add(tf.keras.Input(shape=(2,)))\n",
    "model.add(Dense(5,'relu'))\n",
    "model.add(Dense(1))\n",
    "print(model.summary())\n",
    "\n",
    "X = tf.constant([[2,2],[1,1]])\n",
    "y = tf.constant([3.4,4.7])\n",
    "with tf.GradientTape() as tape:\n",
    "    # Forward pass \n",
    "    y_hat = model(X,training=True)\n",
    "    loss = tf.reduce_mean((y- y_hat)**2) # Made up loss \n",
    "\n",
    "grad_ = tape.gradient(loss,model.trainable_variables)\n",
    "\n",
    "# Print the gradient tensors shape in each layer\n",
    "for var, g in zip(model.trainable_variables, grad_):\n",
    "  print(f'{var.name}, shape: {g.shape}')\n",
    "    \n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-15 . XOR implementation with Hidden layers having sigmoid activation functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensorflow version 2.9.1\n",
      "The tensorboard extension is already loaded. To reload it, use:\n",
      "  %reload_ext tensorboard\n",
      "Epoch: 0, loss: 0.707137942314148\n",
      "Final Prediction [[0.568074  ]\n",
      " [0.6039111 ]\n",
      " [0.55183685]\n",
      " [0.5892746 ]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-12-23 22:28:26.929898: I tensorflow/core/profiler/lib/profiler_session.cc:99] Profiler session initializing.\n",
      "2022-12-23 22:28:26.929937: I tensorflow/core/profiler/lib/profiler_session.cc:114] Profiler session started.\n",
      "2022-12-23 22:28:26.990636: I tensorflow/core/profiler/lib/profiler_session.cc:66] Profiler session collecting data.\n",
      "2022-12-23 22:28:26.990753: I tensorflow/core/profiler/internal/gpu/cupti_tracer.cc:1799] CUPTI activity buffer flushed\n",
      "2022-12-23 22:28:27.092809: I tensorflow/core/profiler/internal/gpu/cupti_collector.cc:521]  GpuTracer has collected 0 callback api events and 0 activity events. \n",
      "2022-12-23 22:28:27.096417: I tensorflow/core/profiler/lib/profiler_session.cc:126] Profiler session tear down.\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from tensorflow.keras import Model, layers\n",
    "print( 'tensorflow version',tf.__version__ )\n",
    "from datetime import datetime\n",
    "%load_ext tensorboard\n",
    "import tensorboard\n",
    "\n",
    "#XOR  implementation in Tensorflow with hidden layers being sigmoid to introduce Non-Linearity\n",
    "\n",
    "# Model class\n",
    "class MLP(Model):\n",
    "    # Set layers.\n",
    "    def __init__(self,n_hidden=2,n_out=1):\n",
    "        super(MLP, self).__init__()\n",
    "        # Fully-connected hidden layer.\n",
    "        self.fc1 = layers.Dense(n_hidden, activation=tf.nn.sigmoid,name='hidden')\n",
    "        # Output layer\n",
    "        self.out = layers.Dense(n_out,activation=tf.nn.sigmoid,name='out')\n",
    "\n",
    "    # Set forward pass.\n",
    "    def call(self, x):\n",
    "        x = self.fc1(x)\n",
    "        x = self.out(x)\n",
    "        return x\n",
    "\n",
    "    \n",
    "stamp = datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
    "logdir = 'logs/func1/%s' % stamp\n",
    "writer = tf.summary.create_file_writer(logdir)\n",
    "\n",
    "\n",
    "    \n",
    "# define model\n",
    "model = MLP(n_hidden=2,n_out=1)\n",
    "# wrap the model with tf.function to create Graph execution for the model\n",
    "model_graph = tf.function(model)\n",
    "\n",
    "#Learning rate\n",
    "learning_rate = 0.01\n",
    "# Define optimizer\n",
    "optimizer = tf.compat.v1.train.GradientDescentOptimizer(learning_rate)\n",
    "\n",
    "#Define the Cross-entropy/Log-loss \n",
    "loss_fn = tf.keras.losses.BinaryCrossentropy(from_logits=False)\n",
    "# Define the XOR specific datapoints\n",
    "XOR_X = [[0,0],[0,1],[1,0],[1,1]]\n",
    "XOR_Y = [[0],[1],[1],[0]]\n",
    "# Convert the data to constant tensors\n",
    "x_ = tf.constant(np.array(XOR_X))\n",
    "y_  = tf.constant(np.array(XOR_Y))\n",
    "\n",
    "num_epochs = 1\n",
    "tf.summary.trace_on(graph=True, profiler=True)\n",
    "\n",
    "for i in range(num_epochs):\n",
    "    \n",
    "    with tf.GradientTape() as tape:\n",
    "        y_pred = model_graph(x_)\n",
    "        loss = loss_fn(y_,y_pred)\n",
    "        \n",
    "    # compute gradient\n",
    "    gradients = tape.gradient(loss, model.trainable_variables)\n",
    "    # update the parameters\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
    "    \n",
    "    if i % 10000 == 0:\n",
    "        print(f\"Epoch: {i}, loss: {loss.numpy()}\") \n",
    "        \n",
    "with writer.as_default():\n",
    "    tf.summary.trace_export(\n",
    "      name=\"my_func_trace\",\n",
    "      step=0,\n",
    "      profiler_outdir=logdir)\n",
    "\n",
    "print('Final Prediction', model_graph(x_).numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tensorboard extension is already loaded. To reload it, use:\n",
      "  %reload_ext tensorboard\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "      <iframe id=\"tensorboard-frame-59d5ac858464346b\" width=\"100%\" height=\"800\" frameborder=\"0\">\n",
       "      </iframe>\n",
       "      <script>\n",
       "        (function() {\n",
       "          const frame = document.getElementById(\"tensorboard-frame-59d5ac858464346b\");\n",
       "          const url = new URL(\"/\", window.location);\n",
       "          const port = 6006;\n",
       "          if (port) {\n",
       "            url.port = port;\n",
       "          }\n",
       "          frame.src = url;\n",
       "        })();\n",
       "      </script>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%load_ext tensorboard\n",
    "import tensorboard\n",
    "%tensorboard --logdir logs/func1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-16 . XOR implementation with linear activation functions in hidden layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensorflow version 2.9.1\n",
      "Epoch: 0, loss: 0.7000243663787842\n",
      "Epoch: 10000, loss: 0.6931632161140442\n",
      "Epoch: 20000, loss: 0.693149983882904\n",
      "Epoch: 30000, loss: 0.6931474804878235\n",
      "Epoch: 40000, loss: 0.6931470036506653\n",
      "Epoch: 50000, loss: 0.6931470632553101\n",
      "Epoch: 60000, loss: 0.6931469440460205\n",
      "Epoch: 70000, loss: 0.6931470036506653\n",
      "Epoch: 80000, loss: 0.6931470036506653\n",
      "Epoch: 90000, loss: 0.6931469440460205\n",
      "Final Prediction [[0.50000817]\n",
      " [0.49999997]\n",
      " [0.49999997]\n",
      " [0.49999183]]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from tensorflow.keras import Model, layers\n",
    "print( 'tensorflow version',tf.__version__ )\n",
    "\n",
    "#XOR  implementation in Tensorflow with hidden layers being sigmoid to introduce Non-Linearity\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "# Define Model \n",
    "\n",
    "\n",
    "# Model class\n",
    "class MLP(Model):\n",
    "    # Set layers.\n",
    "    def __init__(self,n_hidden=2,n_out=1):\n",
    "        super(MLP, self).__init__()\n",
    "        # Fully-connected hidden layer.\n",
    "        self.fc1 = layers.Dense(n_hidden, activation='linear')\n",
    "        # Output layer\n",
    "        self.out = layers.Dense(n_out,activation=tf.nn.sigmoid)\n",
    "\n",
    "    # Set forward pass.\n",
    "    def call(self, x, is_training=False):\n",
    "        x = self.fc1(x)\n",
    "        x = self.out(x)\n",
    "        return x\n",
    "\n",
    "    \n",
    "# define model\n",
    "model = MLP(n_hidden=2,n_out=1)\n",
    "# wrap the model with tf.function to create Graph execution for the model\n",
    "model_graph = tf.function(model)\n",
    "\n",
    "#Learning rate\n",
    "learning_rate = 0.01\n",
    "# Define optimizer\n",
    "optimizer = tf.compat.v1.train.GradientDescentOptimizer(learning_rate)\n",
    "\n",
    "#Define the Cross-entropy/Log-loss \n",
    "loss_fn = tf.keras.losses.BinaryCrossentropy(from_logits=False)\n",
    "# Define the XOR specific datapoints\n",
    "XOR_X = [[0,0],[0,1],[1,0],[1,1]]\n",
    "XOR_Y = [[0],[1],[1],[0]]\n",
    "# Convert the data to constant tensors\n",
    "x_ = tf.constant(np.array(XOR_X))\n",
    "y_  = tf.constant(np.array(XOR_Y))\n",
    "\n",
    "num_epochs = 100000\n",
    "\n",
    "for i in range(num_epochs):\n",
    "    with tf.GradientTape() as tape:\n",
    "        y_pred = model_graph(x_)\n",
    "        loss = loss_fn(y_,y_pred)\n",
    "    # compute gradient\n",
    "    gradients = tape.gradient(loss, model.trainable_variables)\n",
    "    # update the parameters\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
    "    if i % 10000 == 0:\n",
    "        print(f\"Epoch: {i}, loss: {loss.numpy()}\") \n",
    "print('Final Prediction', model(x_).numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-17. Linear Regression implementation in TensorFlow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensorflow version 2.9.1\n",
      "Epoch: 0, loss: 1.1912292962960103\n",
      "Epoch: 100, loss: 0.06553162133740813\n",
      "Epoch: 200, loss: 0.045865258680501945\n",
      "Epoch: 300, loss: 0.04464764651573694\n",
      "Epoch: 400, loss: 0.04415248599448223\n",
      "Epoch: 500, loss: 0.04386758238901734\n",
      "Epoch: 600, loss: 0.04369143911972347\n",
      "Epoch: 700, loss: 0.04357636116238922\n",
      "Epoch: 800, loss: 0.043497590679425026\n",
      "Epoch: 900, loss: 0.04344162545185315\n",
      "Final Prediction..\n",
      "\n",
      "MSE in training: 0.043401084869746635\n"
     ]
    }
   ],
   "source": [
    "# Importing TensorFlow, Numpy and the Boston Housing price dataset\n",
    "\n",
    "import tensorflow as tf\n",
    "print('tensorflow version',tf.__version__)\n",
    "import numpy as np\n",
    "import sklearn\n",
    "from sklearn.datasets import load_boston\n",
    "\n",
    "# Function to load the Boston data set\n",
    "def read_infile():\n",
    "    data = load_boston()\n",
    "    features = np.array(data.data)\n",
    "    target = np.array(data.target)\n",
    "    return features,target\n",
    "\n",
    "# Normalize the features by Z scaling i.e. subract form each feature value its mean and then divide by its \n",
    "# standard deviation. Accelerates Gradient Descent.\n",
    "\n",
    "def feature_normalize(data):\n",
    "    mu = np.mean(data,axis=0)\n",
    "    std = np.std(data,axis=0)\n",
    "    return (data - mu)/std\n",
    "\n",
    "\n",
    "# Execute the functions to read and normalize  the data\n",
    "\n",
    "features,target = read_infile()\n",
    "z_features = feature_normalize(features)\n",
    "num_features = z_features.shape[1]\n",
    "num_recs = z_features.shape[0]\n",
    "\n",
    "X = tf.constant( z_features , dtype=tf.float32 )\n",
    "Y = tf.constant( target , dtype=tf.float32 ) \n",
    "\n",
    "# Model class\n",
    "class MLP(Model):\n",
    "    # Set layers.\n",
    "    def __init__(self,n_out=1):\n",
    "        super(MLP, self).__init__()\n",
    "        # Fully-connected hidden layer.\n",
    "        self.out = layers.Dense(n_out,activation='linear')\n",
    "\n",
    "    # Set forward pass.\n",
    "    def call(self, x):\n",
    "        x = self.out(x)\n",
    "        return x\n",
    "\n",
    "    \n",
    "# define model\n",
    "model = MLP(n_out=1)\n",
    "#print(model.summary())\n",
    "# wrap the model with tf.function to create Graph execution for the model\n",
    "model_graph = tf.function(model)\n",
    "\n",
    "#Learning rate\n",
    "learning_rate = 0.01\n",
    "# Define optimizer\n",
    "optimizer = tf.compat.v1.train.GradientDescentOptimizer(learning_rate)\n",
    "num_epochs = 1000\n",
    "cost_trace = []\n",
    "loss_fn = tf.keras.losses.MeanSquaredError() \n",
    "# Execute the gradient descent learning\n",
    "\n",
    "for i in range(num_epochs):\n",
    "    with tf.GradientTape() as tape:\n",
    "        y_pred = model_graph(X)\n",
    "        loss = loss_fn(Y,y_pred)\n",
    "    # compute gradient\n",
    "    gradients = tape.gradient(loss, model.trainable_variables)\n",
    "    # update the parameters\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
    "    cost_trace.append(loss.numpy()/num_recs)\n",
    "    if i % 100 == 0:\n",
    "        print(f\"Epoch: {i}, loss: {loss.numpy()/num_recs}\") \n",
    "print(f'Final Prediction..\\n')\n",
    "#print(model(X,training=False).numpy())\n",
    "print('MSE in training:',cost_trace[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-17a. Linear Regression Cost plot over Epochs or iterations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'MSE')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.plot(cost_trace)\n",
    "plt.xlabel('# Epoch')\n",
    "plt.ylabel('MSE')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-17b. Linear Regression Actual House Price vs Predicted House Price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Predicted House price')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the Predicted house Prices vs the Actual House Prices\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "plt.scatter(target,y_pred.numpy())\n",
    "ax.set_xlabel('Actual House price')\n",
    "ax.set_ylabel('Predicted House price') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-18. Multiclass Classification with Softmax function using Full Batch Gradient Descent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensorflow version 2.9.1\n",
      "Epoch 100 : loss: 0.1338 ,accuracy:0.8789\n",
      "\n",
      "Epoch 200 : loss: 0.0873 ,accuracy:0.9148\n",
      "\n",
      "Epoch 300 : loss: 0.2326 ,accuracy:0.8364\n",
      "\n",
      "Epoch 400 : loss: 0.1002 ,accuracy:0.9087\n",
      "\n",
      "Epoch 500 : loss: 0.1162 ,accuracy:0.906\n",
      "\n",
      "Epoch 600 : loss: 0.0862 ,accuracy:0.92\n",
      "\n",
      "Epoch 700 : loss: 0.135 ,accuracy:0.8753\n",
      "\n",
      "Epoch 800 : loss: 0.1392 ,accuracy:0.8938\n",
      "\n",
      "Epoch 900 : loss: 0.6744 ,accuracy:0.739\n",
      "\n",
      "Epoch 1000 : loss: 0.2276 ,accuracy:0.8221\n",
      "\n",
      "Results on Test Dataset: loss: 0.0156 accuracy: 0.7982\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "print('tensorflow version', tf.__version__)\n",
    "import numpy as np\n",
    "from sklearn import datasets\n",
    "#from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "\n",
    "\n",
    "# Function to Read the MNIST dataset along with the labels\n",
    "\n",
    "def read_infile():\n",
    "    (train_X, train_Y), (test_X, test_Y) = tf.keras.datasets.mnist.load_data()\n",
    "    train_X = train_X.reshape(-1,28*28)\n",
    "    test_X = test_X.reshape(-1,28*28)\n",
    "    return train_X, train_Y,test_X, test_Y\n",
    "\n",
    "# Define the weights and biases for the neural network\n",
    "class MLP(Model):\n",
    "    # Set layers.\n",
    "    def __init__(self,n_classes=10):\n",
    "        super(MLP, self).__init__()\n",
    "        # Fully-connected hidden layer.\n",
    "        self.out = layers.Dense(n_classes,activation='linear')\n",
    "\n",
    "    # Set forward pass.\n",
    "    def call(self, x):\n",
    "        x = self.out(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "            \n",
    "# Define the Categorical Cross Entropy that does a softmax on the final layer output logits\n",
    "loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n",
    "\n",
    "#Learning rate\n",
    "learning_rate = 0.01\n",
    "# Define optimizer\n",
    "optimizer = tf.compat.v1.train.GradientDescentOptimizer(learning_rate)  \n",
    "\n",
    "\n",
    "X_train, y_train, X_test, y_test = read_infile()\n",
    "num_train_recs, num_test_recs = X_train.shape[0], X_test.shape[0]\n",
    "# build the model\n",
    "model = MLP(n_classes=max(y_train) +1)\n",
    "model_graph = tf.function(model)\n",
    "\n",
    "X_train = tf.constant(X_train, dtype=tf.float32 )\n",
    "X_test = tf.constant(X_test, dtype=tf.float32 )\n",
    "y_train = tf.constant(y_train)\n",
    "y_test = tf.constant(y_test)\n",
    "              \n",
    "epochs = 1000\n",
    "loss_trace = []\n",
    "accuracy_trace = []\n",
    "\n",
    "\n",
    "for i in range(epochs):\n",
    "    with tf.GradientTape() as tape:\n",
    "        y_pred = model_graph(X_train)\n",
    "        loss = loss_fn(y_train,y_pred)\n",
    "        #print(loss)\n",
    "    # compute gradient\n",
    "    gradients = tape.gradient(loss, model.trainable_variables)\n",
    "    # update the parameters\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
    "              \n",
    "    accuracy_ = np.mean(y_train.numpy() == np.argmax(y_pred.numpy(),axis=1))\n",
    "    loss_trace.append(loss.numpy()/num_train_recs)\n",
    "    accuracy_trace.append(accuracy_)\n",
    "    if (((i+1) >= 100) and ((i+1) % 100 == 0 )) :\n",
    "        loss_ = np.round((loss.numpy()/num_recs),4)\n",
    "        print(f\"Epoch {i+1} : loss: {loss_} ,accuracy:{np.round(accuracy_,4)}\\n\")\n",
    "                            \n",
    "#print('Final training result:','loss:',loss.numpy(),'accuracy:',accuracy_)    \n",
    "y_pred_test = model_graph(X_test)\n",
    "loss_test = loss_fn(y_test,y_pred_test).numpy()/num_test_recs\n",
    "accuracy_test = np.mean(y_test.numpy() == np.argmax(y_pred_test.numpy(),axis=1))\n",
    "print('Results on Test Dataset:','loss:',np.round(loss_test,4),'accuracy:',np.round(accuracy_test,4))    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-18a. Display the Actual digits vs the Predicted digits along with the images of the actual digits "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual digits:  [7 2 1 0 4 1 4 9 5 9]\n",
      "Predicted digits: [7 2 1 0 4 1 4 9 6 9]\n",
      "Actual images of the digits follow:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzkAAABxCAYAAAD28W2FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAABzpklEQVR4nOz9d5hd2Vnni3/W2vHsk0+lU1GlUpZanYO7224bG7dtbIMNAwwMDFy4DFwzDPz8TCDMvWCGiwcehpnLJczA3DEwpMFg44Az2J1zt7qVc5VKlU9VnRx2Wr8/TqkkdUtqqVRqVZX253nO83Sf2meHr9Zea71rvUEopRQREREREREREREREREbBHmzbyAiIiIiIiIiIiIiImI1iYyciIiIiIiIiIiIiIgNRWTkRERERERERERERERsKCIjJyIiIiIiIiIiIiJiQxEZORERERERERERERERG4rIyImIiIiIiIiIiIiI2FBERk5ERERERERERERExIYiMnIiIiIiIiIiIiIiIjYUkZETEREREREREREREbGhiIyciIiIiIiIiIiIiIgNxQ0zcn7/93+fzZs3Y9s299xzD0888cSNutSGI9JuZUS6rZxIu5UTabdyIu1WTqTdyoh0WzmRdisn0u4moW4Af/VXf6UMw1B/9Ed/pA4dOqR+9md/VsXjcTU2NnYjLrehiLRbGZFuKyfSbuVE2q2cSLuVE2m3MiLdVk6k3cqJtLt5CKWUWm3D6YEHHuDuu+/mD/7gD5a/27VrFx/5yEf45Cc/ecXfhmHI5OQkyWQSIcRq39qa593vfjd33HEHv/3bv02lUqGvr489e/ZE2r0J53T7z//5P6OUolKp8N73vveqdINIu0i7lRFpt3Kup6+DSLtonLh2ovd15UTarZxIu+vnnG59fX1IeQ1OaKttNbVaLaVpmvrMZz5z0ff/6l/9K/XII4+84fhms6lKpdLy59ChQwqIPkuf8fHxSLsVfn7sx37skrpF2kXaRdqtvc+V+rpIu5VrF+l25U/0vkbaRdqtn8/4+PglNbscOqtMoVAgCAJ6enou+r6np4fp6ek3HP/JT36ST3ziE2/4/u18BzrGat/emqZFg2f4GnfxDuIkeZIvkUwmI+3ehAt1S5PDx+NJvkR/fz9PPvnkJX8Tadcm0m7lRNqtnGvt6yDS7hzROLEyovd15UTarZxIu9XhnG7JZPKafrfqRs45Xr+lppS65DbbL/zCL/Dxj398+f/L5TKDg4PoGOji1vrHDJQPgIa+3JCFEJF2b8JFugmjbe9z+TYHkXbniLRbOZF2K+da+zqItDtHNE6sjOh9XTmRdisn0m6VWNLtWt31Vt3I6ezsRNO0N6wozc7OvmF3B8CyLCzLWu3bWJcYWAgELk0gtfx9pN2VuVi38xQKhUvqBpF254i0WzmRdivnWvs6iLQ7RzROrIzofV05kXYrJ9Lu5rLqKaRN0+See+7h61//+kXff/3rX+ehhx5a7cttKKSQJMmwwMxF30faXZnL6fbNb34z0u1NiLRbOZF2Kyfq61ZOpN3KiN7XlRNpt3Ii7W4uN8Rd7eMf/zg//MM/zL333suDDz7IH/7hH3LmzBl+6qd+6kZcbkMxxHYO8jzxpRW6X/iFX1gz2sl4HJla8oeUEoQAQ0fpGpgGoWNefHy1iWi64Pmolgu+T1ipoHx/1e/tnG5JlSVBGoCzZ8+uCd3WOpF2KyfSbuWs5b5urRNptzKi93XlRNqtnEi7m8cNMXK+//u/n/n5eX71V3+VqakpbrvtNr70pS+xadOmG3G5DUVeDOIpl1GOAPDUU0+tGe3CPSPM3JMg1AVKh1CHVofCT4TEequ8c+g4pmwbMI3A4BvHdqKP2ZhFQXwqxCqFxJ8fJZiZXfV7O6fbaQ7TWtoW/vSnP70mdFvrRNqtnEi7lbOW+7q1TqTdyoje15UTabdyIu1uHjcs8cDHPvYxPvaxj92o029oBsUWetUQ3+JzPP7446RSqTf/0Q1E6DpoGs0Om9oAhLoiNBTKUFj5OvlUlUd7D/NvOvZjLQXF1UOXn1WSb8lt1OYtQCMwBQn7xvmZDootDLIFX3l8i8/x8MMP37BrvaUIAUIiTQOkRAUBBAEqVBAGq3KJdaudEAh9Kfhak+0dxjBEKQWhQvkerH4psItYt9qtAdZaX7eeiLRbGdH7unJuKe0uF+CuliPgEZrW/io8l00gfONxS9xS2q0hbpiRE7ExkPE41ffdRnlQo7zb4+G9h7Gkj6X56CJg0F4gp9XYaU0ikQRLL7kmBB/peInNsQJHaj3sH+qjMJ0kfaoLs9lCVaqE9fpNfrq1j3QcZDZD0NfB6Q8naPX4pI4YZE742DMNxKvHUK3Wzb7Ntxyh6whdR+3awvydKdyUoDISouwAraxj1ASpU4rOxydQ1RphsXRD3CQjIiIiIjYAQiBjMdA0ZCKOisfeeEiooN4grNURPZ1U9nYTGgKr6KM1ArSqi6zUEU2XYHomGnPWAJGRE3FFRCLO7N2S9F1z/Pjgfj6eew1DaG/6O4nk0ViNR2OHOJ1+mRdyQ3yh8w7GerdjTqUQvg+RkfOmiJhN2JmmtDXOP/nOJ/k3nc/zwU3/jLlEntSpONnD5q1p5JgmwjSobElQeLtHV77Ef9v1V9xmenyp3sML1RH+5oV7yRzLoBU0RL0RDTgREREREZdGSETMRhgGYUcGP2Nf8jBjwUQohdebYfZuSWCDM21ilhX2oklsxkSvtBALi9GYswaIjJyIS6J1duDtGqLWYxKMNLi3e5zt9hTa67ZwC0GDuoKJIMGo24kmFB1aFVt4bDXK9GgxkkIxaMyzyVngUJ/EKmZxggDmF27S060fhG3j5mK4SYEjXQDcQENrgebeWDesNYsQCMtCODEaHZLhoWl2ZWbIaU0kBv36Ik1nnL/v2EOtP05MlxjzxVvSqJaOg4jHIZemuitHqAvSL8/gnxq9rnPKXBYAVaujfB/VbKE8d5Xuen0jk0lkR5Yw4VDelcZNSBKTHvZUFVmuE0xMb0ithGEiDB2xeZDa5jQiUJhlD+kGaNOLqFIZ5bqEzeabn+xqkBpC05AxG5FtB3OHhYW2h8ANdlGNWOcIgdaRQyQThPEYfjZGENModen4tqCVFXiXqDkpFJglB7PYQaNHwPYqccuj0h1DNTVkTcOo2jiTNr3TychbZQ0QGTkRlyTY2s+JHzRI9pb59zv/ge+In8YSEsn5DGqeCjjqpTjpdvPNxZ08f2YITVP0ZUtkrTr/PP80H3Aq5DSLe6WLl9rPX992D17Cor+ZRTtx+iY+4fpApeJUBi3qeUFarxMqRbVhESsqjGoIwerE5KwrhESkEoSZBJVh+IOtf0Of1iIjdTQhuMN0uc0c54nB0zy55w7iuRg94wlYXLzZd/6WI3NZvKFOFnY5dP/QGJ12leO/s5vU9Rg5uSy12/tAQGyihqg2EIslgmjRAgDZ1UHprh4qQxoP/+DLfE/uBf7lyz+I8WyO1FiaVLFEUA5WLZ5uTSAEMpVAxGJMflsH9gdnqLVMqmNpjIqg54UYiSM2slQhnGmtihEiTQMRd6AzR2VXDiUEqX0SdXaqHbe4kfSNWFWEphGM9FHd5FDt0yjv8JFJj7uGR9kcn+fO+Bl2mlOX/O1LzWEO1PrJm2XemThMXHgYIkSi8JB4SvJ/jn6E8JkcTM9c8hwRbx2RkRNxEediHVopk1hXne0dc4yYs2SljacCqmGLigo57qUpBnGerW5hvJHl4GyeYNLB12C0qTMVS3E028s77AKGkFjCIC5cDNvHj5kEpuTNnd4ilKHhORDYCo0QD4XbMkhXFEbdhzB885NsJKSGNA2CXIpm3sHLBOS1Fjl53vg+l/wipTcITUVginZCglsQFbNw0yZuWrArNU3eKnHY3nN9JzUNWmkNpYHwHYy4ieFHO7PnEoSEKYdaXqOeV7wteYK32012dM+yvz+OXpOkdB0hxUUxyusaIZCWhervxs051HsVD3ZOMN1Isq8cwxMGoSFAqXZCkFW4HkIiuzoJ8llaHTaVAR1CSJyOIwoWNFuo9W7kLD2nlk4hbAt0HXQNXI+gMH9LuilfM0u7fcK2kHEHdB3l2CjToLw5TrVf0uhRxPM1OhM17suMsdWaYbc5zVbj0kmSDHGKlGyQ06ps0uvEhcSRBvKCspP9TolxPftWPWXEFYiMnIiL0Hq6CbqzLG4z+cHtT/JI4gg7jRpgM+b7HHLzfG7+Tl748m3YBbBKIUZD0VUNMOcrICWBo+MlYvy3H3yEnntKbDFnucv0MQRYtkfNCQmNW3PSea0ESZt6H3jdHoYImAskYtwm9/RZVK1OcAsNdELXkekUIp1i9P1pvDuqfPvmkziXy4ITgdeTYv42g9pQQN4qtV0er1OuoCPJwh6BH1coqSOUTt/jvThj47e0m5B0HETMpnBHmtxHz/LO7CRvi42hE+MXh77I/u5Bfr3rA+S/kUJUa+3dhnWul9B1ZCIO3Z0c/dEMW+84yz/tPM0HU/s41OpnqpZiVqaQnoGamG7HKFzPMwvR1tm2mPzwEOGji2SdOe5NzzHVSDHTHKar3kIslgnm5lbvQd9qZNsNTyYTzL9nM6UtEj+h8LM+5rTOlj9zCE+Obog2dMMQAq2rAxF3qO3sYv42g1ZWkdizQD5ZZm98jD6rRE6vMWLNEBcufXoFRyiS8vJLsINaSC42jikECWGiCXGRgROxtth4Rs7S6sdlUWHUKVwBFbPwsjatDNzrnOZe00UT7VXyhdDmRKuHg4U8PS96OKeLiGIF1WigXK/tfyoEumVhZtKo92zmjNtJSmsSUgAkugxRukJF2zhXRWhKvKRCd9oBjJXQxKgI/DNnb612LER7lzEWI0zGqA/5fHjrYR5InsK40vsuzn3E+ZSgt5BufsKglVOQ9kjKJlIo1PUaObaOlw0RaZdEookuQxoHcjhCglrnq+fXgTBNhG3Tygl+rO8l7rTP0KNJNCG535LcY07yZ/kFMK2lYsobQC9NQ9g2QdqhY8c8vzHyt6SlR07TqIcFUmaLeT1A+jphrXb91xNyWefakOIXd/4DXXqZQb3I/lY//zG3GeVYyJpx/de6WQjRjm2K2aiEQ3VQ4u1okE3XuK1zimczw4SpWLv9CLX+29CNQkiEbbXHi26d6haPZE+V/7D7c9xtFnCkhiPM1/3o0skGLiQhLRwu3oYNX///19vJrnVeN88Wsv28b0ilvQbG2g1j5AjLQm7ZhJ+OURuwqfVqiAC0pkKEIANAgTPrERsvg+cjGi3wfcJiafWCIdc7lomb1gliCkP4eASc9mA+jPF/n/4Qp58fxJkSOKMFKBQJm02U6y7HhmiZDK27R6h3Gziby9zvnCSvVzCERjG0KU6mSJzSsQtRQN5lEQItl0Uk4sxvtdh2xxm6YxWeLW/hH/xd2PNqTXQebxX6yDCNrZ24KY3SsIaXUuzdfZpvTx9kSF9Eu8zWRL9VxOt3qVgG8w/mcbZ2YpRdtHITUanjT0xtXL/9pUGomdNgc41NHSWSWpNaeP11qrSGhzUbo+VbJDtL9CdKHE12IGM2yvU2ZFD9myI1yHfSyiep9yh2WlMM6A1sYRGokCeaOi80tjA63sXu+iyh57Oe/dWEZbVd1EYGmHgkQ6NH8Z29B+jUPJ5r9vFEZTvPzW6i+s0eMjMK58Qcq/GmybhD/W1bqeV1tC1V9lpnOdjq47+MvZexuSw9pwLkzAJhdRUMqpuAPjiAN9RJo8uksFfHzYTk90zzcM8peowym8wC8604tWQ/VjxGWGusf7e8G4SQAhWP4WVjVIYE77rjCNucWbYZ8zhSw7gGh3lPBYz5PqXQ4oyfY9LLEqrLL649PzXEYMNblTZ/s5GOg0wl265+tgmGTrM/RStn4CYEzQ5x3jsghOTZkPhUC63qos2W2slGFoo3bVzYMEaOtCxqWzLU8hoLd4bs3nOammcyW07g+xpBIFGBwDoao8vMoDUCzGIL0fQRLRciIweEILR1vLggsBWGCAiV4oib55TbxYlXB9jxP+cRlTrB9OwlG61IJ5m706LWH/KBgZPcZ5UwhEQiKQZxYhM6mZMBeqG6ITqAG4KQkE3jdaeoDMNvbfoyrtL4xIkPMzWToa+wfidHK6E1lGPmXpNmZ8jQ3gmGkwv8UNfTPGg1OL9V80YGzHkGehcoJOLM+0kqZZPYjEF81saesRCzc6jWBm2FQiIMnWZOcv/QGYZiC2S02qoYObLuEptVgCRptrg9NcGBxI523IB6awqwrjWEFHjdCUrDFn53O7PkgJ4A2hOkx6o7+fyZ27DOGqhGc90bgtKyEMkE5S1JtPcWeHvXJN+TeZEeLcZrjUG+eGQv+kmbLZ+ewB89Q7BK7UHGHeb3GlS3eHxg+Di3mYLHainGnh/AmRQkjxTwp6ZX5Vo3A783S2FvjOowfPR9T/Ng4gR7zWkG9PZ7K5EczZ7mK8khbNtG3KqLCleDkIRxCzej0xzw+A99X6ZLs5BXsVvzejwCjnrdjLsdvFwZ4lix64q7NbXxJKK5MZIOCCdG2J1FmTpeyiKISQp7DWpDPrHuOu8YOklM8/BDjVao841Xd5M6GCM2b5HWJFrNbZdwiIyc68SyKA/pVDcpkv1lbk9PUA9Npp0UbqDRDAyCUHKCLqYtG62lY1QtpAfObBqrtAqTnVAhfYXwQ4z5GswttIMEK5X1Megrhaw0ic3FSJwx+b9OfIR8vMzJxU4qdYvkqERU6qh6ve0LfKlTmAbNToXoadFnFZcNnAsR60GLm4yyLbykQWArkrLJfBBnbjGJNm1hVG+t3PuNLoPG9haJTJ292UkG7QU6ZJ03Cy7J6yVuy00xHUtyWAkadYNW1qLRo5PIJOic6UaVq4SVysaqZyC1dnrUeIxWBrbFZ3G0Fi/WRjhZ78SoX+f7JwShLggNRaddY8gsEFgKlpKW3HIIgTBN6j0W5RHIdlYwL4gTCwkZbXSwMJ0mtSBgA7Q14cQIsylaacmW7Dx7EpOkZQuwOF7tRjttE58AGs1VGfuEriMdB5VLU+8L6ds0T1xr8VzL4MXSJmLTgvhMiKivz8VKYVkIXafa71DaodDyDbbb0/TpiyTlxTEfnUaF0oiOdIdwjhcQYxOgwo3Vh70ZQiB0A2EaiN5uVCKGqLcQ9Saq5Z7P9KgUIgBCQUtBU/l4qu1cZiCQQrAQBIwHCZqhwUKQoBZaFPwkJT9GNbBYcOPUfYPRYo5606RVtNFKOuIKzTo5Idptf70hNbREHEwDujsIUja1LpvKgEZgCrwEhCa4m1p0dZUZSi1yW3wSS3qEStBUBoeGephUHdQqGrV8Er0JzkwGoxai1wO0uodWaaJOjxO2VifT4pXYMCOSSMapPNTgR/c+w13OKPdZ8wC4Si17SwYKKlt0Kg+b1EKLaT9NJYzxTHELZ6uZ674HL5TMl+N4LZ34K130vJBAX2wgjp9eN5lQwtPj2BPT9B/J0TzQzYzRSbbq0+EGaHNnCaam236Xl9kiD5M21s4S3zF8iLcnji5nuoq4eoQU+NkYtV6DIOORky4TfgZ53CF3SBEbL986u2BCsLhD448f+W90yAZJGWAAjtTgTdwN7jAbDPd8A09BZdDARbKvuYmTzW7+9tBdxBby2DMN5IlxgmLpLXmctwJh6ARbemn02DS3tvihzPO81OrnVw98iNpMnJEZ77rOr3SJ74CfUNybHuXdzii/kg4RttVe/NgIsSZXy5KBI+JxCrcL7nv3YR7MnCRxQb/nqYDnJ4bIvaCTHPdQ63Hy8zpUR4ba1vZO8w/1PMND9hyOMAgJefHMEJs/X0VbrBEsFlflejKZRA32UBtJcc+9x/m1wc/zxcpefmv8/ew/Msj256roEwuE6zHDn9TQshlwYszdqfHx932BYXOO+6x5EsLAEBfvPNxujWO+p8DYnhR9X+shXapCq7V+FlNXAaEbyEwaMklm3t1DdRBiM4LkRIA976K/3EQ1GhAoRKAQnmQ6cGiqFsUwRoAkJVo40ueJ+lY+O3MXi80YU7MZVF3HntaxC2CWFYmzLloroLvpITwP0ai1Qx2ugGq5BOuwZIGMO6ihPvyMzfRDDrVNAZnBIv9keB85vcqwWSApGySlS1y0k0klXxcT++FdB6jsMKgpg2LoUAziPFPeynQzyeHZHhrTCRKnkgz+rzpqZu6G7/xvGCNHSYEQCokiUJJKqAgQeEsR7oYI0VBkpE9eCwhUnS3GIk2lYQuP004XntKWtyANESAvY6qfOyZAEiqBFO30vq1Q57TTwWLLYaKzj1bOQPghmqaxXroe5bntbUWlsKVE6Rqi0UJ5HmG1dtnVImGYyJiNm7LoiC+w2ZojI5tAe+BrKp9KaCM9kK66Neu7XC1C4iV0WhmBFvMJgXpoodcEVtF/0w52QyBEO3VqLIabCdlr1ElI6w0Bnpfi3DEGGuml/rdXE4DC5DTdeplnOjdT7cujpENiIgYbwcgRYrk4Yq3TppbXiCVrOAI8pVNbiGHNaWjX2X6UoRFYENohGa1OUmooTZ0Ppr+VOBcIb5n4CcXe5ATD5twbiiY3GybZhRCz7K3vtO9LbSx0TFopDT+u6NYqJKXJTNCiGOp4JQt9bgZVqaK869xdOJcCOJWg0Zug1q2xNT7HZt3GUxoT5RR6SUdbPF9sdL0hpEAl44SZOF465E57jLxWJy0t9KWFnPCCGURSumzLtjPH1fKdJDf1IMuN9jzD9wlr9Y0bawjtDHvxGKqnAz8bo54XuL0u0jOxFwS6rWEIgQKEF6A1Q/SazguNERzpUvCSeEojp9dIazWeLW/hxGwnbt1EmzbRG4L4pMKZDbCKHuZoAVouquW29d1AhY+Fri8naBCWiUglqQ8kaaU16vmQeF+FO7oneXfiEGnZok8X2EKnHoZ4CAKlqKgQA8hp7fbqyICm8tFwkfhU1Ty28Bh3coRKcEQJmuUkKp1ANhqE5eoN1XPDGDkUy6S/medPTr4btzPA6mjgtXRU0QQFZDysmEdHssZwaoFeu8S7UofJyDp32me4LzbKXBBn3OvAFh7DRgFHXnrF01OSAMFckKQYxEnKBkN622ovZy3qocWveB9m1u8iMebQfcxed9XWw2YLZgsgJcrz2vUNrmCYiB0jzN+dpbxZ8M/yR3jIOUleCwCDU57Hc81hPj97B+nTIc6xAswX37JnWW8IQ2d+j4HxyDxv65xh1E/zQnUzibMhsRMF1OIGmJC/CVo6xfQ/3U1pu+KOe08u1SEQ8CapOkNCFoIWFSVoKo1KaGELnxHdJyEtNuktcto0v7jlS3z+X9zFc9NDGNU+tHXsx38O6TiIvh787hRnPgR37T7B3vQkr7odfG7uTrofM0idbmCcnuZ6pp5uxsLfWWd7T4Fho7Bq978ekbaFGOzF7YpjDVT5aGofSaHQcYD2Lk5dBYhpi/SLk6hag8C9vp20m8bSwgOWxeLWOPN3KGIjZdKyxUwQ8uPHf4ATYz10Pq8RFhZQzdZ1T7a1rg7IpJi/r5PKRyts6TzLd6ZfISTkucVhKgc6SI2CKFUIruBGvZaRjsPCA92UN0vyO6fZpLcXDvTL7FT3aYqf7v0H5rpTfKHzTg6+P8/MmQ5yL3cTWwhJPzfRjpndgLFxQtcRpol322ZOfr+F3tXg20Ze4a7EGX4r9l7CsRhKEyAFKgiQZ6ewCzZDYT9/PPEdCAVWMUT64CYFniOwSoreaR/phujVKsILkbVme3HXdQkr1aXisqrtFrgO29ilELqO1t+LSjhUdmRY2KHhZhXZPQXyiQofyp5mhz1Fv77IVqNJCJz1BTUFj9X2cqTay6IbY6aepCtW4xeHvshths9rrsbB1maGzTkesGo4QiOvFwH4to5j7EzO8FVrJ1Pv7CQ+myH9wiT+2PgNe84NY+SoRpPM8Rb2okGtR6fRnSRWh/ikQihFrdfGS9hMdMco9sSYSqXYFpvBMAI2mXV6tBhxUaIWWqRkkx1Gi4S8dJBuS3kEKGxRxCCgW6uyy5RLnVJISJ3Pd53ly71ZjKrRLuK13giDa0r56XfEKG0RtAZcdtmTDGrhsqtaKbQ4WO9nrJQlM++hZgrtATDi0mgazU7FhwcPkzVqzAcJpppp7GIAs/OEG8Dd5c0Qtk15m2LPPaO8v+sgOhqakKDCi1Y1L0VdwUJgU1Mm80GCuGwxqLfdVxPSIgH0xuq8J/YUn00f5nc6/inxt+CZbjTCNAkzcRrdFlu3TfJ/DX6R6SDFhJdltJQje7yGdmSMoNa4rusEMY3+znluy0yS09bX4s1qI3QdPx2jlTXoTBbZblzckkJCXKUwKrI9kK/nSaeQYFkIJ0YzK6G3zmCmiC1CKqHGibEeUq+ZpMZaq7ObIATCieHl4lQHJB/b9Tj3xU6xTfcIlM5MPYkzJYgVAlS9sX5jUgydWq+kMdLi4ewMOWliifNzhtf3dwlpcb+lgBIPWF+hmJf8Vu5RHqvsxZvWSB1yYFZsSLfRtpFj0Oy2uP32UR7pOM77EgfZauj8Wa5MU4udD9VUaskNuYTpefTNdCBaHsHEFMp10Xu6UekkolonmJldrjmk4NZwB9c0wmQcPxujvEmjdVuDvs4iv7jlS2wz5unUNBLCoi1ojHLYZD6MMeeneLU8yMG5PNWaTbBoMZNJM9mXZbdR4Izfxf76AAD3WlUMNOLCI6PViMsWm8w5prrSPDXYQWhqpA47N/Qx1+Hs+9Io18M8u4hRjGEXbLwzOtINMRfbk+nYnEVgS9yExE2lmHPS/GZvH2FMoXc0SCeaLJYdwjkbZYbEe2o41hu30JQSuH7bra1WtqFq0L15nv+6688Z0F2S0mxnEnNjaGUNvcbGdc2SGvpgH2EmwcztMbL3z7AtM8cWYw5DSKrKoxm6fLH8IH/zyj2YkwbdhSLKdTfMasiqIjW0VAKRzeB3+DycPIandJqhgRtqSE8RtlobWjvpOMh8N15vhrDTZVtilrxebA/0VzBwpoIGX6juYqKV5aWFISbLKTxPw3N1dCNgT+8UA06R78i8xrfFqsuBvCnZpLhFI/aOuzDH5/FHz7yVj7u6dGaZuS9JI694ND1NUnr8YeEuvnxgD/Zpi875aVRz5e1HGGZ7gpHReFfXKA8njtElfd4sNmojI5wYlc0xar2S2xLFi/5WDZs82UxzvLUVo3Jz7m810RJxqg8OU+3VKN7r8uHtB8mbZY56HYy6ndhjJtmjHtZUhWA10mMLSdCRpDoUo9kZMmzOERc+X6gNcdbtYPpIN8MHW5jzjXYA8zpD6DoymYTuDqqbfR7cfoqH08fRhKCqWpz2JE2lMx/GqYUWW4w5bjMvTkLQjk0MeCh9gqN7u5noyOG+lMCciaNqdcLmBhkrltwWg3t2Mn9bjNJ2xUc7jrPVmuaz5buYbqWZOtLN5lMtjMUm6nW7parRRCyU2n3fkjET1uoIpdrZDsNbpyyD3t9H9e4BmhmN0laBmwtIDC7yHQMnGLQXGDEWcAQccC3mghTTXpqzbo4TtS6eO7QFraRhzUvMMqRbCqOuqPfE+Ovh+2h27uO/nHwPc0c6+drQTuy9X6ZfXyQpm3RpNYqhjRs47E5Mcvb+DOPzGerHU8TOJNvzwhvwHm8cI8dzCU6OAqAJeX7YXepszSVfcUeKJT/qpcA1y6Qx0kGzw2F4xsU6eRbl2FR35vBjyUtcCGyvHczWO9tCn1tk8jt62TcyiCVGsUWAIWCh5WAWJWZFQbCOfbCvgDB03KFOKkMWpTtd/nTXn5PXAtKyXWCrEvhMBw7/MLWd7scMnFkfMVlYlwPSW4E0DUQui9+ZJNVV5dFYjdN+k2cbm2gGBtIN100Ci5UikgkaWzup9Rj0dM9yX+L0kiuoToi6bEzOuO/wJ6ffRmEuhX3SIj6hiLsKvanwYpKDO7bySi6A++ER+ykQ7fNkZJ3aNpdpFaNH70Rbx6vtfneK0v0t+vKLvD11jKQUPHZmC4N/p2HP1VCTM9dVD0zYFjLu0MoKvjP9Mm+zABwayn2zRHcbFydGaUTSGPDZkbg4ZWwx9PlKaS/7F/uwiut/EiVSSWbu0zB2lfnxrS/xbzr2M+a7fLGyl2eLm8kcC3GeP9lOrLAaGdWkoNkVozwsobfBNmMeA8Xfzd7F4Zk8uVcFxuP7CdepW5awLOjI4OaTDG6Z4//s/3s6NIXEphQGPN/cQsFLMtbMseg6vDN3jF3GSeQF75ojTBwN3hc/wZZts/x1x/3s67kT63QcPH/DlMYQmoYwDebudLA/NMN7Oib5J6nX8BR88sQHmDnVSecrAnP/GKrlEjYu3q0O6/U3hAyElQpUNsDqwzXi93cw/qjA7Kny/Tte5tsSh+nTKwxoBpoQ6MRoKJcXGiM8X9zM6XKOmdk0+pTFjk+XkaNTS2nwz9f6yuzcynP3DBMiKD3bzZZv1Ji5L8Xfdt/NHekJPpB6lUEtwFMuCyR4wDnJ/7b9NV5uZfh3j/8E8VdTqGqVIDJy3oRzHd2ltmiXvlteYFIhqlYD18OcjyMDhbFQR1VrCN/Hno0TxN4oj1AK4YUIBdILUHGbwAZHtjBFyEIYEiifqXIKu6Daqak36Mq7EAIvoeOmBIbjkRQ+jtCRSDwVcNLLcqA5yNxCioF5H2u+CRskYO+GYBgE2ThuzsaxFpAIAiWohDFagb6hU2+f87VWXTkWt5s0uhV3pxbo0ss40ufCripQirryaCpFITCYCNI8U93G3Jks9ozeNnBmfISv0JsBuqPTyhhoLZ0ztRxV5WEogSV0HOmR6ymz4GawCxZdZzcj6k2C2cK68WmXySQylaTcY5HJFRlJF9BQzAWSRs3CLrjoxcb17QAKgezqwO3L0OyAuPAI0ZkKGswFJlpdtidV69VlaIUoXcNLKIx0i5x+3r03UCELoc7LhUHOTuXoK22MhS6lgSZDLOmhoxEoQSmIUXZtpK/axWCvt51ZFrK3hzAeozysUx8K6OsoYQtFJdQ4ONWLOhXHmQvWzTt6KYShEyYdvIROymqSlCG1EIphk5ebg/zJ2NtYrDq0mgahqzHdn4LBdmr8vdYUGQmO0IgJk7iQdGk1NsfmeGxEord6SRyLIY43l+JJ1ukcRGrtxb+BXsK0Q71XcXd2hq3OLIGCYmgyW0gRO6sRm/fB9dZl8okbylJhaK0jB7k0xc1x7N4qI53zbLen6dGqOELhEbAQBBz10kz7XXzm7F2cncpBWcea17DnaGdMrNbaBs4FbUqGIUKAKX2EAuGHmBXFoek8Fc/mgfhJtumLOMInp1XJyCaOMIjLFleoqboqbCwj5xpQvk9QriKkQNRqGJoGnkfgeoiKQCtX0LU3umGopQ5VCIG/d4TK9gS1/pAtxhxpKXi62cWY20X9aIatTywiKzWCdZZ04KrRNBpdOtVNkM+VSUqxHIfjEfB3i/fwj6e3Ye+PEd83SlgsEdwC8SQrRTgxyluS1PKSrYl2coGKMjjT6mChHqPDX5+D+dUg0ynIppm/K8vm7zvOg7lTvDN+hBHdxRYXv4chIad8k2k/zVeKt/OPp7fhTsXZ/Pc+9tgsolpvL2CECqUUhm1jT3fjZW327+jj1KBNWrYY1EMGtZD/tPtvmN6e5hNdH6KVzZM4G5L5R49wcXHZT3vNIgRsGWRxR4r52wT/x5bnuNM+w7Sf5qnGFrRJC/3I0bbrynWskglNo3hPD7P3Spwdi6SlRyn0+VxlD4frvdizElWutK+xXidUK0A5FmqowYPDp9lhTQJtA6elfA61eik82UvfoYDUoYWN4ee/9CqEShKiqCiD0/UOZipJUg3VnmCu1MiRGtK2kD1dTL2/j3ovZO6d45c2P8mwOUdO6uxr5Uh+I07P1ydQxdKqFRm9GYh4nPqmOJU+nb3xBbo0i2eaFt+o7OHzo7eR+28JhsdKKOmDhNKuHv6fOz6E1+Xzz+9/mvvjJ9ltFBjSTRLSYqsM+a7kaxz6rj4Ov6OHmc910TNfhEZzXaaXFrqOiMWQHVmm35OnOgjDD47z73q/CkBF6exrDpF4KUb/1+cRCyX8aq29kr3OnvVGIkwToevU7x1m7i6D+haX37r98+y1pshJcIRBKXQZ8wXPNrbzO4e/jVrBofsJne0HysiWh6g1oOUSLLbDDV6vr5ISy3YZsIs8ZymUJolP+YTfSHA2n2T/9w3wnlidERkyqJpI5EVxZzeSW9bIASAM2u/D61YfL/XdRSwVogpsjUanRKVaOKJ9/LjXwfFGN0ZZIBfL7YDIjbaTs1QwSqRTtNICL+OTs+toiHbahdBjIQw5VemgVYgRX1CExdI1JTK4FRFS4sbbBbeSRntCWg8tppopag2Lzg3q9gi0k3NYJl4cHsiO8u74YQZ1D0cYy+l4z7Wtmgo55fZytNnLgYVe3GmH2LTEPltGnZ1qxy1d8P6KZgvNsRFBQFhJMep10mcs0kcDS+jsNits0sts657jUD6B1pJkrfbA0PbVXtvvbxA3aXRIvEzAiDlLj1blmJtntNmJXhft1O/X4wYgBELXaaUlQb5Ff7qEIaCpFKPNDo6XuzBqS33mRuvrLse5VMq2TtxpMRRbJKPVaafMb6+KlsMY1iI4k01EeWP1fYGSy66jmlDoWojvSLRcFuUH7R29IFiKv7xCvyXbOqJp7RS2sRh+V4p6XtDqd7mjc4K3xU5ji4CmEkz7GWLz4fqOnTuHlPiWJLRY3hmbDxIcq3ZTKcQZOLlAcOxkOxbO0EnaBs1sglqgc7aRZYuVoKm36wIZol03LCdd7k6ewZQ+Tye7EVKi5Dr1JdW0dtHZhEOju50meltqjj5NYy7w2e92s78+gL2gYHqunZDnFlpguSrO1fGyTJo5jUZfQK67zF5ris16u/5SSMhCqHGo1ctr1UHqUwnsWY3UmQby5DjKdQmu5PYoNZAQhpJ6aBLq4KVNAlu2S4Z47UURicAQBpYw8FRAVbUohtl2sVal2tnrbgC3tpGzEs4Fh8fjjD9gMfCeM3yoY4y8BtOB4A+OPELzdJL8kYCwWGoHwG2wVQVtZIiJD/fS6FF03TnNh/LHuTd+GkvoTPot/r/FBzlS6WH0iU1set7Dnixv+FiSVcEyaXYJGj0h3VbbV/ib1V089exunEmJNj+9MVaDL4EQglAThKZgwFygT3OxXreDMxe0+GptKyeb3fzVUw+SPqJhL4SMTLno1TpMzaEukZhB+R5hYQFRb5LZn+Pfpz7CbQOT/Ofhv6VH03CEhqUpfrL/Wzz17ZN8+vDdeK90YWgS5ubb/txrFSGpDtgUb/fpGlxcTmX/l2fvY/RMF11j11eTSug6siOHiDuUt8J33vYau51JbCE45Zt89sCd2Mdteo67t1RCEa2zE9XfRXGrwzsHXuKfpF9kQPeB9gBeCgOm3AzOTIB+aoqwUr3Zt3xDGNZdfqTrKU6mu/nN73mUmfuHkZ5AugKzBB0HXYzq5RcMlRTUey2aWUEr0+77wrTPu/bsZ29ignudU/RpikOew6cW7+Dxma2YpQ3iEqlJlAahDlIoQhRfWridV57eTnpcICptw1j5bRdA7fQ0PfUOqtvTvHz7AHG9xZCxwHbDJ1AhmpB4SlEJbGq+hfRA+cGVjcw1jNbVSe32Pqq9OtmHp/nfB/axySxwyNP408I7+fpX7yY2I+jdt9BeyLnemkwbEGlZsGWQVi5G4W746IMvsMOZpmvJ8J0KGhRDnX8/9lEOP7MZe0Gw6TUPs9hAH5ttp2W/lPGxtPAoHQeZSePbBsHJBF9o7UXfXGNue4BleHQ6dXbEqnx74iCaMJd/fsJr8ceLD/Hi/BDxmQBVqd6wWO3IyLlGhBQI20bFY9Q3efxfmz9Pl9YgIW0qfkhjLEn2kCA+XmtPjjaYgQMQ5BJU72mwo3+GH+1/infFJrGExBAmC6HJM4XNjM3m6D4c4jx9AtVqEd5ivvorQRk6XkJB2iOttQMnj1e7SR8TxKeD5UFvQyJEuyaTBhmttpy84kJKocartUEOFnvpfFHS9Y2xdrBisXTltJ9KEdZqiFaL1BmfVi7GIZmnvklDEwKDtovlt8cqfHvsJaZaaU5ld6EvxhCLa7+LbKUFuf4iezqmyWketVAyPpvDOWHizHqXHqSulqXV1CAbx+vy+N7s82RkC0NIFoIExhmLjkMBsbMVglvoHRfxGI0eh0aX5O7EGHdaFtAuOeARUAslZd/GKgUEM7M392ZXmQtbU1baPGx73GGeYmHPU+wf6qfsxii5NuOzOYyajVW8/DukNCiNSJr5ALO7zruGTjMUW+CHMs8zpMeWjrIohg7PFDZzdibL1sbGaWehJlCS5cLjx0tdpI9DfNo/X2ZBtXeTg7k5mJsjoe1iouQwmUtTTtuEVJbiN0MCwFMazUBHBrR31NZp8VkVj1Ht06kNCH5wYB8/kz3OMc/luNfF87NDDPyjiz06TzgzFy2iXg7DoNUZo95jYG6q8rHOx0lKQULaSzXlDKaDFAfP9DL4uI9VaCIPniKs1d60lprQNIRtoVJxlKFhzwqaymbgvgl+dtM3yGh1+rUqloDc68bzmSDBUzMjTM5kGC76hI3mDVsgW/sj+BpDOg6tXf3Ue0ySPSXyWh1LQDVsMRfk0KsCuxgi6x7hBjNwhGEibItWxqK7Y5E7M2fp1xexhCRUikLY4GBrmNNHe3HGNeJTjfbKerTCckVkMonMZWhsyuKNNNk9MI2jtXjJDTgy303ybIA900BtkEw518pM0GLSj/GN6l184eU7MWd1Bs64qGr1DalCr4QKFXahSfJMnPlsjGcbm6mEE2w1mqSlfQOf4MZwLqWzmxbc0THLzvg0Bu04LjFu03HIJzZRIbyOdL4yZlPb2U29WyfbtUCX1iBQghOezv7mAM60ID5WRRRvrSxFKh6j3m3QyiqS8uL38rBr8leLD/DN8W30VNdp4c9LoJpNkqNQIcOT6S38QPol4lKQliaGkNxhnyGn1aiHFpXA5mSyiyfkFhaal59mCKnI5qpsTZUZcIrcnzxFl96O7wRYDJsUQ/h66QHGXu0jPi3RF+c2xI52mHCobBI0+nwGzPYObF+ixL7BPEpoxE3jkr9ThkY6XWdvapJu7eL3rqXgcDXP8fkurKo6P/6uw7lI6Fg0ugStzoD0Uj2uCT/Fi7XNLJTi5EpNVKW2fusjvVVIseyyGLwuDWaAIEBg2j61HptWOo7VtRtC8OOSwLj4+KWkpHiOILDASwpaOUVgK7R8jbjT4sHO0wwbC8SFT1IKDASG0AhUSEO51FXAc/U7mTrUTXxaYhWKhEFwQVaw1SUycq4RkUwwd6dNdSjkff2nGdJj1JXLTBAy7nZgLQqc6RayUrtMstv1i4zZiFyGRofOQ92n+c70K4wYTRxhUwgbTAYmz1e20PWsJHuohDw7t3GTLqwiMpehubWbxe0WH9n1LN+dfZHjbp6vVfayeDZN7/5pwvlFgtqtqeUpL8U3q7v4/OheBv9eED+9iJiYXSr0dg2oEH28QK7u4sWzfHV+D4V0klxqH+kbnOFl1RGi/T46MVodig907GfQmMeRGhXPJnMMnC/tWxo8Vj7BEYkE87cZ1DYFfEfvKAOawZjvs685xAvFYdKnPdQrR/Bv0AC1VvHTNtUBQavbJykvTlf7bGMLn3vtDsyzJnpxfkNMyAFUvUHnK1WS4zaHe/o4OthBXiuTMBSWMHhnrE5gn99tDnMh9f6vvul5DQRSCDTO14AxRHvRYdw3OO728I/j2xj4RkBssgQTM1c63brBz8ZwdzXYnp9bTlpxW3KSl7cNUpUOefvSxchDU2NX5wTvS+5nk94AYst/q4QGh+d6qJxNkZkP2qmU16GBAxAkTBoDAU5vlbxRJCTkuJvnmcJm1IyNNlvALxTW7fO9VSjBcop/T0ncC2JMPaXRDE3S8QalwSRIgZuG0AqxOutkk+fnHEEoaXltk2FLrsCWRIFtsRneETuBJhSTfpKmMthmzC/twhrI1xlVxdBnMrB4rLCNvicV8TNlxPj0DY2lioycq0QYJjJmE3akqPco9L46m+x5JIKzPnyufDdPL4xgLSq0ShNaGzCNYU8nta0dVAcl/VaRtGxhLDXihVBjX3OI4+UurEqALNUh2kK+KpRl0srqeCnoNivkZJNmaDDdSiObElruUkaTW2MiqaGWkw0ESvFyY5i/O3071dE0XXMNZKlG2FxB21Lt+BThh4gA/FDiqXbcT7szbgdTp40GtbyG5qaILZahXF7Fp1slhISlgO1QV3RpZTRCTngah5oD6A2FWo107ZoksEE5ASm9gSYEHpIpL8N8M450w1sy2Dc0Nfy4QsR8TNF+/kCF+ARMtLLoMyZ2QSCaG2ccUEGAVmliahJzwuEPJx+hy65yW3ySpNZY2oFp0q9VGdad5cK9ngoZDyTF8I27paGSTPhZFvwEO6xJ3m7XloLo2wHR80GcU61ualWbfMlFlusbxvVZ+CFB1aRQd6grC2iS1hqkkw0WEjFUPIaMxxG2BbqOiLXd5Bc3xdhtV0jKdttqKQ9DaOhoWCKgO1mllrVxkxaO46B8f126cwWWRGZcetPtdiWRdGhVemIVTqV8vMEODE2iqjXU0hi5Hp/zhhIEGFUf09FoVi1Oeh3k9RIZ2d5htkVIRqsxnF7guYEsaAo71cIwfIYyRXrs8zuFnpLten1CsSsxzWZrlmGzwKB+boWwQlNpJKW4yLjxCZj0W1SUzhP1XbxYHubImTwjCx6yVL8mb4yVEBk5V4nWkcUbyVPa4nDHw8f5F72Psc1YBBz+fPEB/u4zb8eZVnQ/N48amyC4wf9wN4OFB7qpfU+ZbR1zfHviEIO6XB6Qnqhv5feOvpP6WIrtp0vtLFcbUIMbgd+VZGGHRmPQ57bYOHkNprwM++b7MYuyXaX+EmkbNyqS8HxVbxHyX/e/g+Hfgf7iPEzMEKyGC6Ro+8EbIlgyquSSESl5KHmcv3/3bSxO22yp9CCmpq/7mW4Iug6mQeCE7DYXOeql+b2p93BwLk9uYXUmgsrQcdMhmY4q3Wbb2Jv2kzy7sJkzszmGN0pF9WvEzeh4gy36eopkZAOwKIdNimHIkzMj9D0ZEJtpoAoLN/tWVw3luqixCfQJnZFKH4tPDTOTlDzbfxe+A/XNHrFsg49seY1f7n4JTwWM+yFzocPvTHw7h2bybzin70vksTiJM7Dwdpd/+Lb/h4GlWJxAKV6sj/D3k3vQxm2M8XGC2bkNUwdFn6+Sea2HaqGDA5sG+KBTYoc1ySO9J/hKaxf1TWlihkajN4Gb0qj2SyojAWZPjfen99OnKWoKJoOAjAzokDH6dMHPbfo6x/N5/uDUB8gcHEIr1QjOTq47t65mh8GHdr7IO5LHGNGrQIyHYuMM9xbImXW+9qG7sQtxckc97JkG2kwR/+zELTNOXg1hs4V+bILURIyFnQP88cjD7E5Nk8w8R4emGNBhExV+uf+LTOaTANjCQ0ORlC6GCAmUILzAaJEo4jLEFgJLSKylhAIDWnuR0BLnFzNCFAtBOxnVoXKe157bSu8zIVvmXYwDY+3SBpGRs0awLdyMSSsjuDN9lofsChKTlvI508iRHFMkJlyYW9x4qZKlhtA0Gh2SdwycYpczRV4LsISNpwI8PM60OqjOxYnNS2SlgX+Lxo+shMDS8JIKLemRlE0soVPyYxTrMbQW7exYG73j1nVCUyPUQRMX71h5JQvtldeunMbyahACNA1laIS6wJQBhgh4vadaSjbJpmvMNXSU+foN9zWIBFsIPKUzVU9Rq9l0rlZNJSkJY4qM01iOPakri8VmDL+pI4JbbCFjKXW0b0mcZItup4K1tJPTVCFNJak0bAZmGmizRcINMiEH2gk8ltyP5emA2FycWDqJWcnhJiVKM2g2JK919nMq+yweklNeN9NemmPzXTQnEm84pfQhcxIyx+qUtzp4nE8X31I+k60Mc8UERlmgGo0NtVIvWi72Yogfkyx6DtDuewbtBbLxBs1cEuk51Hp03LSg1h+SHV5kU3qRnFYloF0MeTZIkNcrJISPhmCnUSAj6/xOJsTP2Bh+2N75XWeEBmyLzbDTnCEp24upOanjGE1uT4zzpb7bqFtGO7GFihHzAuSC005dfi6j3IXps0PVLgJ/iUQsYum45eD3jTLeqhBVqUCrhVXs5/RiBwCnEjnqqkyX5pIUgkFdMmK0+/dztadCBAHteOuAEI12AW1NtN1KXz8yvr7ujU9APfSYC3WOVHo4Pt9FYlyQ2jcD9Qb+Yukt8QKIjJyrJOhIsrDToDYQMmQWkEhedE32Nwd5fmwTwyfqGFPFDWfgCMNEbt+M1+lQGQl5NHOAPn0RR2h4KuDJZpxTbjefPnw3fd/QsAst1MLizb7tdYWX1AjyLr0dJVKiRUsFPDe7Cf9AiuyZcN2twF0zQtDa2s3s3TbV7W1D75yZs6rF/oTEG+qiuN2hvCXk0Y6D7LXOkpGSQIWEKEJCXqxvpvZUF10TCmNijcZUqLDtDqpJjKLGN+oDFAOH7enZtu90phsrlWrXDFrBxFAYJjIRx+tO0rdljp8cepy91iQSkwkvy+TZHNakgVarbrjYw8siNfShfsJMgsUdkh/b/iw7rCnyWttVraIEM0GCRt1Em18kXChu2N1s1Wq1XT9dD8f1iJkG8ckkflyn8Pwmvi//rwHQXBA+pGYDOsuX6MdChV73ka7Pkq1IXbkccC3GvW7+/tW9dD9ukJhooeqNN/5+HaPKVdLHquiNOMer3cwEDXKa4F3OUbo2V/jTH3uQsmuRs5qkzCaDsUV2O+3YnefqW/laEONPDz6AOOkgd1T55J2fpU9fJK/5DOp1urfMM/FIN+mTFpkzk6vjvvoWEuqCQWOePk1hLxUZN4SGRPJw7CQ/ec/jzLpJDt+dZ7EZ48zJTtJH7kCvK5zZAOkrvLgksAR6Q2GWfWQrwJivIVrn38swGcPLxpBeiDG52K5tWKmu7dIBV4tShK6HCEK6ny1TKaQ5G8/y73q24ccVcneFrV0FRhIF7oyfwVU6i36cZmgw46YourG2x4MMSOpNbotP0KFVudOaZFh3rnjpV13408K3cbCYZ+Zb/STPKNInaqjCQntO8xa530dGzlUSJEzqvQqRb9KtVzCExvFWnicWtxHMxDDGzxJMz6L8jTWoCUOn2Z+k2mdg5Gvca02TkTqWMKgrl0Otfp4vbkaejpF5aoywXLllA+RXim9LkpkK/YkSlgjwUMwtpMiOgjPjbfzaI0JS7zGpbPPJD7SzsgTqvF8+q2TnCClodlhUBwVaX4377DG2GjoSa9nAAThZ76LzNZ/4qSLMzq/OxW8AynVBCvSq4JX6JhzpMhIr0AgMjsbzCCeGUGplRo5pIOIOXtrgwe7TfE+iALTdEhb9OEbBWIo52Vj93ZUQmkbQkaTRG6fZ7/FDqVfp1hw04RCokKbSKIYOYVNDlSuElY2bcU75fnui0mzCYntRSxwDA0gvfa4KIdD7+whzSc5Zy54KOdLq40ijl/gJk85vnkE1GgSNjWXkhNUacmyGOD3M1hJUQklGhmw2dfaac/zTnZ8/f+wFneBpv8nvzr2Lw6U8sefj9H2zyPj7MryyfRNuTGNQmyAtTe7tGueruxJUPIfsZTK1rWWUhA6tSlZzlhehJBIpYLuh8fHcEQDCfEigFL/eew9/mbkXVTJpntbRXGhlwHcUZlliz0v0OiQNiXZBGvJW1qLa1z4+4wVoixrC9WAjGDmwVPQ+gFcOknilvYDVmU5CNs34d+XZv8VhtDdLrdeiFWrM1FM0fIPZUgK3biK0EKkp7JhLMR9jwC7Sry8y/CbWwym3m2+e2UpjKsHmZ1pY+8+garW3PBlVZOS8GUvuCW7SQOWb9HeUcGSLunL55uJOnju4hdTYUtzERnIrEgJpWch0iuKIQWUEtnUXsMX5DDihUky0spwut1Nnq1YLPO+WCZC/XoRlIUwTNyXY1jHH1vgcc6HDXAhqxiI16mLNVNsZsjY4rZQg21diW2YORwSA9qa/eVOkhrQthK4jkgmUY1PcquPtrrO3b4qkDLiwC2wqn0oYUPEsRKjW9rusVNslw/PRmjBez9IfK7LDnsJKeTx1124Ca4T4VED8dOmKz6J0SZCwUIbEtzVCQ+I7klZaUOsXbLEvrvMSqPXn+rJahKZOYAvQw+XkGNCehB5xe3i6sg2tpMM6LcD4ViM0DXdLN8URG7ffwxaKmUDjrybv4/RMBx0TaslNbX3tQlwVS7uxslSncKibjxk/wPvzh/jxzD5soRETJppo7zJLBAc9l6frW3itNsiXX7odc06j55SPXKxgF9I8PruV+UyCPeY0OU2w1ZnheE8XJzsHoCOLFgTtopnrxDPArIT8j9lHOJ45xrudU/RqsUseJ5EgQm53znBicxfzzThnOrMEgcRxWqRNj0rDYrFmoVoa80UL6Z/PXBfEFGHaBU9S2prEqCWx53qILQTEZpqIV45uKDdJFQSoRhOp62SP+5gVjdZYlm/lMhCC1hKIAIw62K22sak0cDMxjlkuYUZSTDrAxYsOLeXTUj5frffzdGUrT0xsgRfTZOcV1kwVLlGo+60gMnLeBGGaCF2n0alx38gJbk9O0CEbVMKAp4+P0P81iTNVb/s9bqAsQ0I3EMkkYVeGxTsD3n3nId6dPUxSmstGjofiaKWH6aksuXmFqtYIo1icq0MIZDKBiDs0ugQf7X6FjFZj3OtgrNVJ6pTEeOoAYRCsm0FppQgpaHQJfmTzy2y1ZpZrZFwv0m4b6SoeozWYxU3rVO9t8Jv3foa8XiQtLzakFoKAycBpZw3zFfgBag0bOsprZ9wzqooTxU5imsfdHWdxxDjV99i8dl8/LxzYQscLuXZhwMvg21DvFQS2ws/66AmXRLxJf7pEv1PkIeck8LqV4LUry41DCkJbw41LpOViINoJK6DtulvezjdGdxCbke04uog3RZgmhb0xKg/VeXDTGI4Q7PM6GHtugM5Diuz+IsH8wtpecFghyvcJKhVkEDD49RzVg3389/dm+cBD++mSPpZmoMGyofNYbQe/e+Cd+BMO2/6mgXF6hrBaw6/VSY92c/pQL9N9Kb4z+zLbjSbvcI6R66/yHxffj9uXxgSE56+b8cSZdvnmi3t4tncTuds/S69z+Z1RieQ7nBnePfQFQqC5TS19314uC2hvFAaK5bivc2goJNBUkqNeN/N+gr+f28uh6Tzy1STDJxIEG8jIIQwIa+1i9fGvlohr7ZhrtKXx8NwidaguGv/Ujk0c7coRKsF0Ls2FRk6IohS6LIQa/+n4e6k+30lyTNH3j2dQlQphrdH2croJ73Fk5FwJIZCZNKQStDKCwdgiPUaJYmhRDIGKgV3w0ErN84FuGwQZs1E9HbS645jZJtvjM+T1ItAe0Auhy7jvMLqYxZg1sMpqTU8I1xxCIlJJglwCL6no0KrYwuO4n+dsK4vWXJmb0XpFaZDQmsTl6j2zcGIEfR34SYvSZotWRpDvLDBozJORLhoagVI0cQmV4pDXyTPVbUwUMmyq+wh37bsKqlBhVhWzhSTHdZ/xrhQdsk6vUSRISo7ku6luyiDCyxuOganwOjyEHZBMN8g5DTpjVbYkCvSaRZLCJ7xgZ60aWBhlgVlWiFuo0K8QAi/eDgK3bA+5tJPjqYC68jhbz9AoOGQrUV/4pkgNLZVAJJM0czDQWWTYabuGNpWBXhcYtbDtDrmRtVQK5ftY802UJliYsflyZS+9xiK3WxM4somnJJ6SPFfajD/l4ExL9EKVcHEp5isM0Csu9qxFU3c42upji3GQAIu8XiKXqFPPJxAqhbFQhHUSN6xVXeypGI0gyRcG7qKpDrDFmGNEP9/nSCGwhY5EYgkDS6zcLc9TAZqYoagvcjadww11DnXHUX1d6LpOsFjcWGOyUle1KC0dB5lO0UqYCMcnF6u/oQByXbm87HZyqtVDYSZFx5TCmfUJiyXCWv2mbgBERs4VELpB/d5NzO82aN5V53uzz2MS8qXK7Ryvd5M8oWHuP952VdtgsTj0djP53hz1HsVHtr3M96VeWcp/bnPKb/Hf5x/hcDmP+GaWkacraIUy/kbKJHSDkaZB5fZuFrfqGNtL7DbnmQtMnlzYyrH5LpLlDTywv0UEW/sZf2+CZlfA/fcc5f70KHfHRhnR3eXCgx4BJzyNuSDJLxz4KOqpLB0TIeaJ0+0Oeq0HjquQ7P4SWivFwkgvn+A72Zae473Zg3wotY97bzvFxI726tvlCJC0QoMAgSNdDBGQ14tsMeaxRUBOu3jH62Cpl95nm5jji4SzhRv9hGsHw6A0olO6q8XDfWcxaCdfKQTtQsivHN9E91MaqTNN1ErqON1CaOkUzXtGqPcYxO6d5z9u/Vsc6VFXijk/hV4Hs9xeaNjoKNdFO3YGZ8xiKBzmT2ffi5tVZPcUyNoNqp5J09OpvtrByFeb6KUGamqWsNVaNgC1kxNsanZT35Ti97oe4bVNA7w/u593xqb4roFX+f33fhvmlM1IsRsKazfO8ELkyXGGP+MSJG327budZzvuQLx9kV/d8wVs4WEIH0MEbNOr5DTrfNmBFWIIjT4tpEt6ZDIv8IHUq/yO+V5eLuzGmc7S8w9T+KdGV+fh1hFqx2am3paiOgg/fOfjPJrcz4heB84nHjjq6fzc8/8UzsTofzEk/cJZVL3Zjs++yR5OkZFzOYRAmAb1Tr2dUa2zyLDuUgsVZ1tZjhe7sIqqvZW+AQkdi3qPIuhrsceZWK5dAFBRBkcrPZwudNAxESCPn2kXZ9zIK26rjabRTGs0OxX9yRppqbEQKBZbDvWaTdqLtFwpQtfb+mYtGv0+yXyFH+t5grcvV2M/v9oXKsV8EGfaT1OZSTB0xMcqtNoGznpwvVQKOV8meVojMBNMzGUIlOCh9AmS0qNLK/CANY92hUTYFRVyyktRU+ZyvE1eL9GjhRhCw35datCqa5GYqaImZ1ZWlHWdInQdNwnZjipDsQU0IQgJaSqohDaypJOYcDEKdcIoLvHKmAbNToNGl2RHrsB9lqCqFDOBoBrYSI92oVl/be+krgpKESwVHI6NZcjFctS7JXOZDAuJOEFDB0+SGwfz+CRhrd5eHb9gvA1LZUSzhSOGaBWSHM908XDaJi3tdgbAvkWmyRI45tpPib9EUC5DtYaMO3QEQ7gdMUaHUxzf2oMtfAzh48gWGdlEE+6Sa5pACoGBtpzq+Fpo7wZBYuln96ZHeap/O0rohM4bi9luaJbi0b2sTa0f/D6X++Mnucv0McT5+WC7Fk4CNWmTPgWJ0Rr+2PhNvPGLiYycSyDjcdg8iNfpULg/5P33v8qe+ARNpdjvdvPl124jNmrSN7YOJkErxO2K0XvXNG/vPsmd1jgXNpV9zU0cf2KYxDgkjxcJG83IB/1akRLfAT8TkFuafLtIKi2LoKEhIyNnRQjDpPG+O1nYrVMbDNi1Y5yRxDx5vQKXGPCaKuRoq4/D9V7sKYP4sVlEtU6wTvzWoT3B0YKArOujeRncRA+/ueWj/FouQDg+luMhxOXbU7NuYo5a6PXz05/aZo9H7zrAVmeW706+yoB+PlA3VAJcb6lA7cafzAtdR6ZT0JmjMeLy01ufZq89jo5GVbUY81McbPVjz0nsU3OoWmPNuznebIQTo7xJUh8I2BqfA9qrwX9XvIdvTm8jdcbHHJ0jLJZu8p2+xczOkwwV8XEbZzZOYNponkKECudshbBcaRdCft17p4IAWi20Uo3EqSxnvDwvZjfzz5JTDOmLPJI/yTNyM26uk1gy2fY+WQ8ppVWIarbQJgrEFmwGv9LDn518H0oAol1Lpz4QINIuQoIQimy6xg8PP8+INcNes3DZhAVXQ14vkeipUvOTqNj6y1C3UoSuI/Zso5mPM3O/yZaHR9mVmmabMY8h7OUaOfNhg+NejH8o7yZ9XND5Wg1taoG1NHpGRs4lEDGb2nCKWl5j+64z/Fbv49SVRymEE608icMmnQc8rLG19Y+5mrTSGj+56Qk+HD+DIy9+uY/W8+SfC0gcnCEsLGwsP9W3CCEEfkygJT2yZgMNQagkTU8HVyKCyMhZCcI0mLtTZ/g9owwnFrg/eYouvUyX9DmXAvlCPOBks4vj5S7sWQiOn77p2+vXSlhZSlc8NU3itXbWvs4dm/E6HJo5g2bO4greamQXQ9KPnySYnVv+rvnB+/iHxE6OdXfzkHOcAf28JgoQ/sZPiHGOc9n5vFyc/v4F/kV6FLmUdMALQyb8LKPNTux5hT965mbf7rpA2SaNfEh8oMKw3XZ5HPU6+eb0NqbP5NhxpoY/fvYm3+VbTzC/AEveIc6LF/9NcYV8H0uxPapaIzUWoLkaJ/Z2AtCjeTya2o8fSp5O9xCPO4RhuE6MHIXyXPzpGQDs02PkoV3YGZCxGP49O6jnTZQUKAmVIYcvO3u4O5siny7Tex2JOnNalU3ZRY42TAJLu06HuPWD0HWqIymKWzXU7RV+ffizdGoeXZp1URHQ+UCwr7mJ1xb7SZ90ka+dIFhjYQuRkXMhUkMYOuQyLOzSqfeFvDM9hSYEc77gheYmni8NEysorJk6bLDiZJdCijfOjnQZEhoCZRoI20Z6V/abVkF4PmbpQpe2pe1QNA1x4XUMA6FJRDKJN9CBMi/RtSwtZIkgxDg9QzBXWF8pvKXATcNg9wJbnDkkknJoU5mPY8/qGNWN37Zej7b0j6ohzqfnVRLh+IhNA+hLaWSVrtHY0kGzQyfUBKEO5/rdwAT/tioP5EbpMUoMGwWSsokhxEUpf8+xEBh85eQuglMJ+s68dQXKbihBgCzXMUKQLQujZl7RyDEqHjSaF7070gsJajrlpkVTGXBBSVRTCwgzCbRslrBS2fDGjjBNgs4UrU6LhFlYNnAAKqHihepm9i/2YdTWSd+zBlCmjsq5bOuYo0Or0lI+hxv9TI92EJvQkfXW2izCu8ZRLRdnqoUMLE5Md/HlwSRxaZKUTQbtBaoDEmf3ANaZBThx+mbf7spZ6quU52PM14iHqm3kaILAtDg520moBPfHT3K72c7KFhJSCl1ebuWY9ZMcbAwwXs8y6Cxyf/wUGa3GHWaZtLzF3NIuQBgmMp2ETNvAqe5ucV/vJGnpERdy2f3PJyBQiueaw/zxqQcpnM2wo9RAeT4qXFv94DUZOZ/85Cf5zGc+w5EjR4jFYjz00EP8xm/8Bjt27Fg+RinFJz7xCf7wD/+QxcVFHnjgAX7v936PPXv2rPrNrzbSthDJBM3hLOn3TPO/Dezj3fHD6Bgc9bL8z4kHOTnezdajdThwHP8aXBJOqyPMMUGNChKNDB1sZS9xkVw+RinFKQ4xwWl82hO6w4cP88ADD6z6s14PhgjwY4IwFUMGAVK/8lKJcl3Cag2C4LwhIttpC4VpIJOJ5ZUZABWPoWyL6pYUk++QLDzxDRqvHMCbnkWYBtbIMJmPfgCjpxutIRn6cj/ms1VO1V/ibHh8TWu3jGHSGnD5PzZ9iy3GHIbQmPbTxE6ZZI+HGLOV6x7kV9LmkmSv86rXhyREXuhLLUI6OqoU7+pcduHzHEn5O6v88I4n6DMXGTYKSHHOQArp0+rkNG05uQCAIS49cJ30Okj9fYLOL51A1WqES4PnetTuHMr38c9MIDQNKQW29ibvZxC8YfVNrwfoizZFJ04ttIDzrrlZq878QA8OvchTwXI8wTk2Ul8HIOIOlZEEtbxkq1NaNnAAZoIYXx/dQWMywabC9Rt7G027yxE4JrcNT/LjfU8wqBcphT6Pz20l/7gkPt2EwrXHut4q2l2JsFpFf/kYSSdGcesOfjP3fu7tOsO/7voWDznH+d0765xNxuh9uhPr5OiysbBetVOeS3h8FCnF8kJpx8Iw1aEcR/tsDnf18wHnCCEhngo45dn8p7FHGZ/PoO1LkjkR8upWydce2Mnm7Dy/NPj33P7GDf/Lsp7HiUsh4zGCkT6aPTH0ty/w32/7NH1ahT7dQr8gw2Y99KipkL+euhf1dx0MzQTIMzMEa3B38JqMnMcee4yf/umf5r777sP3fX7pl36JRx99lEOHDhGPxwH4zd/8TX77t3+bP/7jP2b79u382q/9Gu9973s5evQoyWTyTa5wc5GpJMFgN7W8wY50gd32BI70aSjFuNvBmUIWOW+g1WqE1/iPWWSOAbaQIotCcZIDvMITPKgeRVsK7B3jKGc4zh7uw8TmRb7JRz7yEY4dO7amtMvpNWp5ifQczA4brXnl6bhe85DFGsIPwPUgDME0QNMIHRs3G0Np542cwNbwY5Jqvwa9DYKx43R+193EtvVCEDLzZ9+i8Ht/xMjvfAw3naDRZTFlnGQsPMIecS+mWrvanSuyKhwbLeaT10tkpIvEIUSieaC54arEOF1rm3NIcJJDAFQqFVKp1HXfw9UiPTjd6sKWHqEqcWF0bFe8yvhAJ3JpDunHYFv3HG9PHCWv1dikmxcFmEqci+qXXIq6cikEAafc7dilgGBu7qK/ryftLsm5KtessKSNUogQVCAIkRfpGyrZLpYaXnrXayP1dQBoGoEJgQWW1m6E5yqwF0OHejGGPa+h169/gN9w2r0OYVlIx6GRMhi0quS1MgYhHlBzTWKLAcZiE7WCrGobXburQinCRgMZhphFxfR8mtFYB2EXJIVHV7bCdI9BK6MRs6y2i5vvr2vtzrndnevn9GoTowxeXKPkXxyPI0WIIQM0LWzvbiuFEqBrIaYWoL2utwyReIFGGArEJbxE1v048Xp0HS9j0cxodCeqbDNKJIVcNnBCFCEhRz2Lk143pwsddM0FWIUWrNGwhWsycr7yla9c9P+f+tSn6O7u5qWXXuKRRx5BKcV/+S//hV/6pV/iu7/7uwH4kz/5E3p6eviLv/gLfvInf3L17nw1EQKEpPzgMBMf9ejtnuFHup9it1FiJjB4znf487H7SH0lTnzGR0xdewrGu8Q7Lvr/3eo+HucLlFkkSxdKKc5wgs3spFv046t2J99oNNacdt+VfI3Kj9jMuUlaoY7/JhXQX5vrpXiyG9kS6DWB9MGPKUIL/C6Xu7acIW2eXynWlzqinFHjLmcM+29iwKmlD5Qe0vjh+0v8sPpfdNw9wK9Xv4Opv9vH0Lb30DOaw3PbgfxrUTstmSTcNkitx6Gvo8A2vYojr8Np+Apca5sD2KXuYo4JPv3pT/NzP/dzN+S+Xo8KFenTIX/9/H3khxZ4YNcoI/L8BPrnN32Jx//5TjylESiJLT0eSRxhm17FXjJmQi6ccEtYmoRe/P15nmlm+N2z7+boZA/DhTdOTteLdjeMczuror27diEl1yZ2poI4M0lYr7/hpxuprwNA1/Acge9ATLbbSlW1KAQBT1bvJPecQe5wA/P07HXHaG447V6H3LKJxTtzlLZIfiB9ihHdZyEMWQgMFkpxtp6ch7l5wsa1u+tudO2uGqUIXY+OA3U01+G1e4cZH3TYpNf55W1fZGI4y39c/CjZfYPISp1geoa7/I2jnarUyB73MCs6p97RjkuSSAwBI7rLL236ItP9GT7V8TBH9vSwNT/HTw0+Rl4rsUkPuHBaXA5tpitJwoqB8N7YJjfaOCFSSeZ3mTR6FY9kJ+iU5rKbd4iiGrZYCEM+duDHabzUQeqUIvnyOKpeb3vrrEGuKyanVGpnPsnlcgCcPn2a6elpHn300eVjLMvine98J08//fQlX4RWq0XrAguw/DrXh7cEIRFSUO+SvHfnYW5PnGW3UaJTi3HKF4y6XcwtJBk53sCYq6JWoZiWT7uTMJaCoRvUcGmSo+ei4x5++OGbpl2IbLvvvM6ff0iP8Yud+6/6PJ/PZfl/rXdTatiUKzFCT2LFXVKxFvf2jPMfer9B9ir8YM9NWI8tuda8t6dOd/wYvyv3MF6v4IzsgjOzy8ffTO0ui2ngZm2aOY28XSennc9aFSj5JtGl18fVtDm5tGLz/PPPX/Y8q66dCrGKAfaEwWw8RV3pBBesmj1geTxoHQTabeD839rPceGxF3bIr/9bSEiAIlSKUbeTY1PdhNM2WqPyppKvWe1uJJeJ43EDDadax7/Ke1+Nvg5uonZCEBqC0FRYS9uJngqphAZTzTSJyQDzxBRh+fIV2VfKehgnrgU/HaM6IGnmA4aMeRLSYiFsUFYWfkuHYoVglTKqbTTtrgkVos+WSWuSylCMYugwQp1H7AqhXeLXul38jIMeKhBvXKRc19p5LtZCi9AUFFsxwuW9aEla2txvKVrmLHPdr5EytnN/5jTvtGdJSAu4IIskIfXQotkykE2JCMINP04o26SVA6/Dp9csYV1QPqCdLj9kPrRYPJtm8FUfZ6JBMD27ppNYrNjIUUrx8Y9/nLe//e3cdtttAExPTwPQ03Pxi9DT08PY2Nglz/PJT36ST3ziEyu9jetHCLRsGhGL0ewUPJI+xjZzmqTUqSuXP5j+AE8fHyG+38acnESVK+3UqdeBUopjvEqGDhIiDYC75PNucfFkv6uri6mpqUue50ZqZ9RCvjh3O83Q4N3xY2zWVx6Mt9Oc4XsHXqIa2Cz4cVqhTlpvkNCabLNmcMS5rdDzE9gLV+CbKuCxRi9jbidjzSx/8++eJXd7L79mfDe14yaLr7Q7lmTNvsjN62ZpdyVEIk5pi0m9V/C2xDwSyVTQYNRP8GRpG8kzIYkTJVhc3dSp19LmAGZmZi57rhuhnT1dI3s0RcG2OX5fDzk5TkbKizrZa6WuXBaCgIrSGfVyLAQJ/ufZt3FqtBu9YJA+AVYpRJspXnEFfq1rd0NQatnYDq8jp9Bq9XVw87RTjk1tUBH0Nxmy2rv4pVBxzOtmop5GrweoRmPVEzCsh3HiWmnkbeq3NxjqXiSvlfGU4InGCE+VtqHNmuD7SzXqTIQQCNsCw4RWi6BSuerEMhtRu2tCKVgsYfoBmRN9/PuDH2FX5ww/1/c17jA1tg/NMP6eIRLjDp3FMuFCsZ0cSKl1r51qttBnSsRCxbEzeX6neyd32Gd4Z6x+QYymxt2xUTJanWGjsDzOnJuDvOia7G8O82dj9+M8kcCZ3djjhND1dh2w7gTmHYu8s2+UB5wTFx0zF7T40+I9HKr2kjypkzhWQJRr1xSbfjNY8ej1L//lv+S1117jL//yL9/wN/G6LEZKqTd8d45f+IVfoFQqLX/Gx9/iIkJCIlJJgq4MrY6Qd8fGuMfUiAmTlgp55uRmOr9p0fNSk2BiiqAwf92D2VH2UaXEbbx5wN7N0s6o+bx2tp8vze1l3L8+v9Hthsm/SI/yc7lD/Gr3C/xG/hl+sXMf/yp7hA86JSzRTlEdKIVH0P6ocPmzEMJXFvfy12fu5o//7SiFQ2WSH/zfOfT0CONPDZBcShJjzdcvyuyxFtudiseoDENrpMm22AwSwVxg8mR1B6/N9ZI8XSM8epJgYXFVr3stbQ7e+A5fyKprpxRiqkBm/wLJMTjR6mEmiNG8zkxn9TBgMnA45XXyj+XdfHHudqb/YYAdf9Bg26fm6P67Y6S/ephg+vKDDaxx7W4017mruFp9Hdw87ULHJOhvsq1/lmGzne64GJqcaOaZq8XR6x5hrZ1ZaDVZD+PEtdLolHxw5wF+cPB5ejQPj4DnKyM8eWYEe060F6mEbBs5cQeRTkEujUglL7njcDk2onbXSjC/gD96hvThCu5zOZ7dt51DrX4kkg/kD5B9+zQLtytIJRCmsazvetcudD3C2QL65ALWqMVfj97Dtyq7LorPlEjuMiXfkyhwj9U2eqA9B2kpn2dq2/ibibuZO9BN71enSX9tg48Tmra00G/wY9ue4T/2/gP3WhcbLzOByd9P7uHpY1vInPAJDh3DPzux5ksurGiZ9Gd+5mf4/Oc/z+OPP87AwMDy9/l8Hmjv6PT29i5/Pzs7+4bdnXNYloVlWZf82w1FCGQshnBiVPf0UB7S0QcrGEKwGDZ4rNHL0eYutAmb+LSPsbA6Bd6OqFeYY5J7eRe2cJa/N5cs/RZNLM4HyxUKhZuinb7YQDuSY//iEH+kv5OTuSNohGji0hNPR7bo0KokZZMdho8j3piipKl8Drsm82E7Y1M9PH/vtdDieKOHkhej4llU3PMrHw3fYHysk+KnPk9z/1G2ffhjWAsZWAARgF5r6+iV5jEumBjfLO0uyVLcVxgz8LIBnbkqHVoVgAk/w4vFIRYXEnS7TcJQrWoq7GttcwDd3d2XPd8N0a7VQtQaxOZD/vb0nRzo7OOe9BibzALbjVn2XCqN+Jsw5sf4zOK9jDeyvDw2RFg06R4P0RZr0HKXi9he6b1eF9rdCIRACRDy/M5qoNoxTkEor6p9rmZfBzdJOyEIDYlp+3THKjiy7UISIGgpHT/QIFTt1OOrmH58vYwT14oSIIVaThcPEChBGAoCC9RQH1oY0hhK4ztyOfW5M91CK8wTvkmSG9i42q0UWWviTKdQUuNYI8+Mc4qcVuWOjkm+0pElTDtolQTK9zncfHH9a6fCdkKFZpP4hGIhleOb2jbekzpIh6zTo3nYou0lYAiNlvKohD4VJdjf6mXaT/PXo3dRPJ4jdVogqnVC17tiauR1O05IDSEFYsdmirsyLOwRDJvtna1zu15V1WIhCNjX3MrkaCexcR278MZYzLXKNRk5Sil+5md+hs9+9rN861vfYvPmzRf9ffPmzeTzeb7+9a9z1113AeC6Lo899hi/8Ru/sXp3vQpIy0J2dxJ0pjjznYofuO9J7k+cIilNnmsZ/MJLHyWciDHwhE/s6aMo172uHRylFEfZxxwT3MM7iYn4RX+PEcfEZoFZUhekGHzqqaduinbq6GlG/rCIyqY4+B07eX7zNpR8Y3zOOYx0i76OEkPJBX6h9ytsvURx4Jkg5Lcm3sepxQ7KFYegcv4g2ZRkDgmcQog952LMnvdvj4chTP0FrdoJHuz4CM7XCkBh+e9hy8XEZm5qP5vUtuXvb5Z2l0LoBsI0aOVsRrZO8/78QfZak4DF87UtvHJwM864jizNE67SyshK2tw5N8H7779/Ve7haglKZUS1RlrTCIw8R7M5nt+1Db2rwYe3HeA/9Dy7vNp2tXy5cjufffJ+YjOSkW/VMMYnUNUaQbXWHgjPGTeXmLCvJ+1uBEoTKF0hNYUhluJQCKiHAV5wZYNzvfV1l2Upzb1v6/Rl57gzeZYuWQccPKVR9S38QCK8cNVc1TaMdtdAqCQqFLRyIbMPZfHjAu/hMsMdC4wXM9RKMeIHHAaPONBsXvY8t6J2V8X0HF1PCRKbszz29q3cEx9lpzXFe51Rim6M8aHtOH7I0YVvbgztlEK1WoRBQPc3p+ncl2Di23r4z7FHGUkUeF9mP3mtzKDukRUaC6HPIbeDI61e/vvRh6nNOfQ8obHzsbOoRoOgWLpsDb51PU4I0S6bYhqcfW+Od/3AC+x2JnnInsES5w2ysz48Ud/BpyfvYeiLkDhwFrVQXDd1rK7JyPnpn/5p/uIv/oLPfe5zJJPJ5RicdDpNLBZDCMHP/dzP8eu//uts27aNbdu28eu//us4jsMP/uAP3pAHWDGGQZhycDMW8c46jySPMqgXkZhUQhuvaOHMS8zFxhvqQKyEo7zCNOPcwUNoGLRUu7PWMdBEuxjmkNrKKEdwVGJ5BSAWi90U7VSrhT81jVarE5/KEVhaO2nVZeY3bl0y7kvKTYvH0tuYtKbfcMzx1hBH5nqoFRy0ko5dPW8xaU1InfGwp2vImQX8qfO/P6JeXtaOuRJ12vEq57QDGGIrp8NDxHBuunaXRUpCTZAyXNJag6bSWAwbnGlkMec1zCKwii4v19rmHBKcWkpv+b3f+72rdh9XxbmK3ZUa8SkXo6HjZnSagcNrXf0cyAniwiUpAwzAkRoGGi3lU1MhnoJSaOAi0GinAj1Y7sWek8TmFMbEwjVVUF9X2t0AQl0QOCFx20ND4amAmSBkLnCoNSwIL7+St976uqslQBAurfJ4SqcRmvi+hlD+quUK2ajaXYmU3iAWcymnDep5E99RDGdLbE3OsdiMUa9aV+VYfytqdzUo10WWKpgLMcYXUjzbvYVkqsE9pkavXeJ4WjI691Vm3RPcwYMbRjsVBLBYQmt5xGYTnJjtpNyyyZtl5s15PDXDgN7guJfmmdpWjle7qc3EsWd04pOtqxov1vs4ISwL4cRoZRTvy+ynXyuREBevUM8FcQ7UBpgqphgsNAmnZwlXkOL9ZnFNRs4f/MEfAPCud73rou8/9alP8aM/+qMA/Nt/+29pNBp87GMfWy4G+rWvfW3N5aCXHVmmH8xSzwve3n+EO8x5HKkhEcz7CZxxncyJAH2+tioW69ml9Mcv8dhF3+/mXvoYBmATOwgIOMIreEvFtj772c/eVO3Cep2OZ6bJHnRQQlx2sAlNndDWCKwUf5L7MIHxxi0fzVN0F3y0ho/0WgjvvLLCC5DzZVS98Yb0oetVu4tQIXgemhtSbMYYbXZyvNFDqARP7NvJyD+6mPN1wsXiql3yWnW7sFDZzdItLJcxD5/FMk3ioykCx2Bh/wA/uPtnCLI+920/zeb4PB9Nv8TtZsDLbpIvFe/gZLWLV48OIatLuz0CnClJ9wEPs+ShytVruo/1qN1qUu8xePCOo9yROktG1hn3Q35z+v08eWoL1msOqj5x2d9uiPcVllzQBFrD5+RUB9/UdrDXPsses8W0n+ZwsQe3aCG81asPsWG0u0psofPDuWd4R+oYs36KiXuzLHoOB4u9PDW1mdorHfQcVMQnG6jalV1kbjXtrpbQ9VCLRTSlyP/tZr6Rf5CnP7yZd+79X9ydGOMzb7+byf/xHLDBtFOKsFxFNJp0PmWSOJul2dnDp+7M42cCkvkKA+kSh0d7ybxoYZYVW8Zb6JUa2kThqtLBr+dxQpgm4ZZ+mt0x3H6P3UaBnKZhvC7U4C/nH+BbX7sTZ1KgT43ju96aj8O5kGt2V3szhBD8yq/8Cr/yK7+y0nt6S1COTa0fWn0uexITdGvn/SjroYVZgtich6hffnv8Wvh28U/e9BghBFvYwxb24CuPb/E5du/evSrXXynK9/FPjb7pcQLQlj5XWzBYve6/L+fRvl61uxAVKghCRKBoeAZF3+FsPUO5ZRM7q2MfGiOsVC9Zd2SlXKtuwLJ2NwvVahHMLKUBH2+3q+7SDsxqllqvyf5kH4s5h/vjp7jNnGXc6+Cl+SEmChky+wxi8+GyS6VV9IiNlxGN1jXX3ViP2q0mXlzwntxh9lgTGCJgIbR5dbYP/ahD4mx4xR3HjfC+nkOFCukFqLLNRCnNfF8CaFEOYyzUHGRDu2xR1JWwkbS7FEJBqATB0mqZRLLHlOw1y4SUCBnjsBvy/1v8PoqlONlxyOwrIKr19uTqCmx07VZMGKBaAeH8AukXLZLJOEfuzhHcpujXFxkemkP++f/N8P+Q6P/40mVPsx61U57bTm98/BTGcYjlewj1zTQ6dWq1NEe6YsSPWPT+4xyiWCEoLKA896rrXa3ncUJoGq2cTa1HJ5aq0KOZOPJcWYbzfdqJche5Q4rYrNteLFxHBg5cZ52c9YiWzUJnlsqOLNqeMg/kp9hrr5+MKRHrFBWiAjAninhfzfOtVCeaC9KD7mMeYa2+oirftwJivkjqhE6sYFNsJJiJJ/n57n/Gv04HGEWN2KwgXVFkTjTRK63lQpay1kIsllGet+rpfTc6egOer2zmUL2Pp2ZGWKw46PsSdO/3sWcbhGu0uvWqotpLL9p8hdwrSRoTWX7Xehczg6/wtdldlGcT2AsS0Yre26slcdbnC8/fxdc6d7K4K85Wa4ajzV4mWxmOl7s4Od1FUDFInNTJFhXZI00ollGN5qomdrgVUaFClatIP0Cfy/LZWi/N0ODhrlOkzSbTfZvp6O9DVaqr4qK/FglrddLHasSnTBITOm7SIjHhwkIJ1WiuSnKp9YKI2czvNinv8nhH/5nlGnMALeXz2Vov+2pDnD7Sy9bTDfSFGmoFRXpvNreckUNnlvq2DorbNH5i51N8OHGATk3jwiJQERGrjlKgAoITp8n/14t9fVUQrFqygY2IPz0DM7PoQtL1+JI7mhQIIdq7y0vZrVSoUBdMhAJY1Sx1txJGPeSVuQGano74VpbOiYD0oXnCoydRQXBVu/obAqUIp2bo+UdBkI0zanfz/9UfpF5wsCcNYnMKosWJq8Y5XmDwq11U+pP8jXMX27JzvHR2EG8mRvKkxrZvLSIri+16dC0X1WwRrOFCg+uKMCBYXERUKjjTw/ztzN3sTM7wfZkXuMvp4pcHtpDp60Cb1eAaahKtJ8JKBV44gC4kSdme1KtQEdyC46+wbcq3ufzofU/zYPz4cja1QIXUlcefTz7A4eP9dOyTaK8eJ2g01mWbuOWMHBUzaWU0vISiS6+QlAJjqQJtS/nUlceCn0D6ChGoVXVFiIhAqTVdHXjNsmQkqgsGo/XX3a4f7AWPqWMdCF/QPRW2XXer9VtyR0wFIdQbSE0SP5uibKZwSoJYQWEvhKhW9D5fLaLRwp5rEeqCqWM5nsmkMKcMEguCxGSALFZR9Saq3q47dCutrL9VqFARmwt55cQmZvqSvCd1sJ1UwwA/YSCLl0iNupFYHktu9o3cZIRAGCGdRoW4bCERBCqkoVwWQhhbyGJPGMQWgnYNsHVo4MAtaOS4nXFKWyStwRaDxjxZaSOXnPhnApdDXicHKn3oddAakZtLRETErYfx4nF2jnW0jfJyBeV6BM1bwEXtEijPJSjMw2KRns9Vycds8AOU54HvE5Y2pmvPjSCYmUUrlkgdNkm/kkbpGsL1wGvXNQnK1fPp3dfppGrNEwZ0PDZO5miWmbflefwndpLVa/hxRS1volecNz9HxPpHCHTLZ9CYJyebaMKhHrqM+yGH3F7C19IMfbWKPlPC99fvbvUtZ+SEhsCPKTQrwBYeEg2fgEApJgOHV+rDnKlk0ZthO/vXFQpARURERGxEwkql7doRAbQTsOD755NiRKwI5fttLWs1WFy82bdzyxIW5pG1OvFNcfaX+uiyq8hoQ/LWQinCQKMYOLT0895Mk0GSMbcTswj6dBFVubbMpGuNW87IeT0+AQdcxbif49ePfYDW17uIFUJyr87B/CJhtXazbzEiIiIiIiIiYlUIXQ8RhKRfmWH697YwqcPQqTp6oQLFCkG0i7bhUc0m1sEYvyY/yIe372dP/gUOeTY/f/h7KMykGDrpE87Ntxcl1nF7uOWNnEC1DZwDjQEKJzrY+cUpKJYJi6XIVS0iIiIiIiJiYxG24xv9U6MkLygREUVA3UK4HvEJRdl2eK27nzD/HONeN/MncyTOSmJTJcLa+l/kv+WMnNjZCp2vZmlMOHx/+acRjg8lA60u6ToIlKrtVIKRm1pERERERERERMQGQ7ku6ZMNzJrFZGOQ3ZP/ArVo0vWSIDbvoRXKV10vaC1zyxk5weETpE7opIWg12wXPmqnoQ1Rvk/guut6ay4iIiIiIiIiIiLicoTNJtqzB0gISdLQEbqOUgrluhCqdZ1s4ELWnJFzrv6Cj3djcsQG3vk92TVc18in3cCupR7FDddunRBpt3Ii7VZOpN3KWIluFx4faRe1uZUQabdyIu1WzprSzlsyZNZB0omVjhNrzsipLGX0eZIv3eQ7WRtUKhXS6fRVHwuRdueItFs5kXYrJ9JuZVyLbueOh0g7iNrc9RBpt3Ii7VZOpN3KuNZxQqg1Vro6DEMmJydRSjE0NMT4+DipVOpm39YNo1wuMzg4+IbnVEpRqVTo6+tDSnlV5wrDkKNHj7J79+4NrxtE2l0PkXYrJ9Ju5VxKu5XoBreWdqvd5qIxNnpfr4ZIu5UTabdyVnOcWHM7OVJKBgYGKJfbBdZSqdSG/weFSz/ntVir0Nauv7//sufbqETarZxIu5UTabdyXv+s16ob3JrarVabi8bYNtH7enVE2q2cSLuVsyrjxGreUERERERERERERERExM0mMnIiIiIiIiIiIiIiIjYUa9bIsSyLX/7lX8ayrJt9KzeU1X7OW0U3iLS7HiLtVk6k3cqJtFsZN+I5I+3WxvnWMpF2KyfSbuWs5rOuucQDERERERERERERERER18Oa3cmJiIiIiIiIiIiIiIhYCZGRExERERERERERERGxoYiMnIiIiIiIiIiIiIiIDUVk5EREREREREREREREbCgiIyciIiIiIiIiIiIiYkOxJo2c3//932fz5s3Yts0999zDE088cbNv6br45Cc/yX333UcymaS7u5uPfOQjHD169KJjfvRHfxQhxEWft73tbdd8rUi7SLtzRNqtnLdKu42mG0TarZTofV05kXYrJ9Ju5UR93cp5y9qdWmP81V/9lTIMQ/3RH/2ROnTokPrZn/1ZFY/H1djY2M2+tRXzvve9T33qU59SBw4cUPv27VMf/OAH1dDQkKpWq8vH/MiP/Ih6//vfr6amppY/8/Pz13SdSLtIuwuJtFs5b4V2G1E3pSLtVkr0vq6cSLuVE2m3cqK+buW8Ve1uzRk5999/v/qpn/qpi77buXOn+vmf//mbdEerz+zsrALUY489tvzdj/zIj6jv+q7vuq7zRtqtnEi7lRNptzJuBd2UirRbKdH7unIi7VZOpN3Kifq6lXOj2t2acldzXZeXXnqJRx999KLvH330UZ5++umbdFerT6lUAiCXy130/be+9S26u7vZvn07P/ETP8Hs7OxVnzPSLtLuzYi0Wzmrrd2tohtE2q2U6H1dOZF2KyfSbuVEfd3KuRHtDtZYTE6hUCAIAnp6ei76vqenh/9/O3fs0jgYxnH8KV6zOHSpQ1AM3TOpi9Kpg+Dq4ugsVBD7dzh2FCdXB8GpUEspLm4OLg6KLiK4KBScfg531QuK13u81Pre9wOCBk3Cl7wvPFBze3v7RXf1b0my7e1tq1arlqbpy/GVlRXb39+3drttOzs7dnp6arVazZ6enoY6L+1o9xHa+eXR7n/oZkY7L9arH+38aOfHXueX13NnZvYjjxv+rEKhkPlZ0ptj31W9XrezszPr9XqZ42tray/fp2lqCwsLliSJHR0d2erq6tDnpx3t3kM7vzzbhdzNjHZerFc/2vnRzo+9zi/PdmM15JTLZZuYmHgzod7d3b2ZZL+jzc1NOzw8tG63azMzMx/+bhzHliSJXVxcDHVu2r2iXRbt/PJqF3o3M9p5sV79aOdHOz/2Or88nzuzMfu4WhRFNj8/b61WK3O81WrZ0tLSF93V50myer1uBwcH1m63rVKp/PFv7u/v7ebmxuI4HuoatHtFu59o55d3u1C7mdHOi/XqRzs/2vmx1/mN4rkbXGisDF6Xt7u7q/Pzc21tbWlyclJXV1dffWtuGxsbKpVK6nQ6mVfh9ft9SdLj46MajYZOTk50eXmp4+NjLS4uanp6Wg8PD0Nfh3a0+x3t/EbRLsRuEu28WK9+tPOjnR97nd+onruxG3IkqdlsKkkSRVGkubm5zCvlviMze/drb29PktTv97W8vKypqSkVi0XNzs5qfX1d19fXf30t2tFugHZ+o2oXWjeJdl6sVz/a+dHOj73Ob1TtCr8uBgAAAABBGKv/yQEAAACAz2LIAQAAABAUhhwAAAAAQWHIAQAAABAUhhwAAAAAQWHIAQAAABAUhhwAAAAAQWHIAQAAABAUhhwAAAAAQWHIAQAAABAUhhwAAAAAQXkGeeerYT8ScNwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1000x200 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "f, a = plt.subplots(1, 10, figsize=(10, 2))\n",
    "print('Actual digits: ', y_test[0:10].numpy())\n",
    "print('Predicted digits:',np.argmax(y_pred_test[0:10],axis=1))\n",
    "print('Actual images of the digits follow:')\n",
    "for i in range(10):\n",
    "        a[i].imshow(np.reshape(X_test[i],(28, 28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-19. Multiclass Classification with Softmax function using Stochastic Gradient Descent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensorflow version 2.9.1\n",
      "60\n",
      "Epoch 100 : loss: 73.219 ,accuracy:0.8994\n",
      "\n",
      "Epoch 200 : loss: 87.6804 ,accuracy:0.8932\n",
      "\n",
      "Epoch 300 : loss: 97.9668 ,accuracy:0.8856\n",
      "\n",
      "Epoch 400 : loss: 68.674 ,accuracy:0.9045\n",
      "\n",
      "Epoch 500 : loss: 84.322 ,accuracy:0.8945\n",
      "\n",
      "Epoch 600 : loss: 69.5979 ,accuracy:0.8994\n",
      "\n",
      "Epoch 700 : loss: 87.7039 ,accuracy:0.8926\n",
      "\n",
      "Epoch 800 : loss: 94.4417 ,accuracy:0.8851\n",
      "\n",
      "Epoch 900 : loss: 55.3862 ,accuracy:0.9114\n",
      "\n",
      "Epoch 1000 : loss: 74.854 ,accuracy:0.8915\n",
      "\n",
      "Results on Test Dataset: loss: 63.0367 accuracy: 0.9129\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "print('tensorflow version', tf.__version__)\n",
    "import numpy as np\n",
    "from sklearn import datasets\n",
    "\n",
    "\n",
    "# Function to Read the MNIST dataset along with the labels\n",
    "\n",
    "def read_infile():\n",
    "    (train_X, train_Y), (test_X, test_Y) = tf.keras.datasets.mnist.load_data()\n",
    "    train_X = train_X.reshape(-1,28*28)\n",
    "    test_X = test_X.reshape(-1,28*28)\n",
    "    return train_X, train_Y,test_X, test_Y\n",
    "\n",
    "# Define the weights and biases for the neural network\n",
    "\n",
    "def build_model(input_dim,n_classes):\n",
    "    # Create Tensorflow Model\n",
    "    model = tf.keras.models.Sequential()\n",
    "    model.add(tf.keras.Input(shape=(input_dim,)))\n",
    "    model.add(tf.keras.layers.Dense(n_classes))\n",
    "    return model\n",
    "            \n",
    "# Define the Categorical Cross Entropy that does a softmax on the final layer output logits\n",
    "loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n",
    "\n",
    "#Learning rate\n",
    "learning_rate = 0.01\n",
    "# Define optimizer\n",
    "optimizer = tf.keras.optimizers.SGD(learning_rate)   \n",
    "\n",
    "\n",
    "X_train, y_train, X_test, y_test = read_infile()\n",
    "# build the model\n",
    "model = build_model(X_train.shape[1],max(y_train) +1)\n",
    "\n",
    "#X_train = tf.constant(X_train, dtype=tf.float32 )\n",
    "X_test = tf.constant(X_test, dtype=tf.float32 )\n",
    "#y_train = tf.constant(y_train)\n",
    "y_test = tf.constant(y_test)\n",
    "              \n",
    "epochs = 1000\n",
    "loss_trace = []\n",
    "accuracy_trace = []\n",
    "batch_size = 1000\n",
    "\n",
    "num_train_recs,num_test_recs = X_train.shape[0], X_test.shape[0]\n",
    "num_batches = num_train_recs // batch_size\n",
    "order_ = np.arange(num_train_recs)\n",
    "\n",
    "\n",
    "print(num_batches)\n",
    "for i in range(epochs):\n",
    "    loss, accuracy = 0,0\n",
    "    np.random.shuffle(order_)\n",
    "    X_train,y_train = X_train[order_], y_train[order_]\n",
    "    for j in range(num_batches):\n",
    "        X_train_batch = tf.constant(X_train[j*batch_size:(j+1)*batch_size],dtype=tf.float32)\n",
    "        y_train_batch = tf.constant(y_train[j*batch_size:(j+1)*batch_size])  \n",
    "        #print(X_train_batch,y_train_batch)\n",
    "        with tf.GradientTape() as tape:\n",
    "            y_pred_batch = model(X_train_batch,training=True)\n",
    "            loss_ = loss_fn(y_train_batch,y_pred_batch)\n",
    "\n",
    "        # compute gradient\n",
    "        gradients = tape.gradient(loss_, model.trainable_variables)\n",
    "        # update the parameters\n",
    "        optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
    "\n",
    "        accuracy += np.sum(y_train_batch.numpy() == np.argmax(y_pred_batch.numpy(),axis=1))\n",
    "        loss += batch_size*loss_.numpy()\n",
    "    loss /= num_train_recs\n",
    "    accuracy /= num_train_recs\n",
    "    loss_trace.append(loss)\n",
    "    accuracy_trace.append(accuracy)\n",
    "    if (((i+1) >= 100) and ((i+1) % 100 == 0 )) :\n",
    "        print(f\"Epoch {i+1} : loss: {np.round(loss,4)} ,accuracy:{np.round(accuracy,4)}\\n\")\n",
    "                            \n",
    "#print('Final training result:','loss:',loss.numpy(),'accuracy:',accuracy_)    \n",
    "y_pred_test = model(X_test,training=False)\n",
    "loss_test = loss_fn(y_test,y_pred_test).numpy()\n",
    "accuracy_test = np.mean(y_test.numpy() == np.argmax(y_pred_test.numpy(),axis=1))\n",
    "print('Results on Test Dataset:','loss:',np.round(loss_test,4),'accuracy:',np.round(accuracy_test,4))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 2-19a. Actual Digit vs Predicted digits for Softmax classification through Stochastic Gradient descent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual digits:  [7 2 1 0 4 1 4 9 5 9]\n",
      "Predicted digits: [7 2 1 0 4 1 4 9 6 9]\n",
      "Actual images of the digits follow:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x200 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "f, a = plt.subplots(1, 10, figsize=(10, 2))\n",
    "print('Actual digits: ', y_test[0:10].numpy())\n",
    "print('Predicted digits:',np.argmax(y_pred_test[0:10],axis=1))\n",
    "print('Actual images of the digits follow:')\n",
    "for i in range(10):\n",
    "        a[i].imshow(np.reshape(X_test[i],(28, 28)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
